/*HEADER****************************************************************
*
* Copyright (c) 2008-2009 Freescale Semiconductor;
* All Rights Reserved
*
* Copyright (c) 2004-2009 Embedded Access Inc.;
* All Rights Reserved
*
* Copyright (c) 1989-2008 ARC International;
* All Rights Reserved
*
***************************************************************************** 
*
* THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
***************************************************************************** 
*
* Comments:  This file was generated by "gawk -f def2c.awk" script.
*
*END*******************************************************************/

#include <rtcsrtos.h>
#include <rtcs.h>
#include "snmpcfg.h"
#include "asn1.h"
#include "snmp.h"


#if RTCSCFG_ENABLE_SNMP

extern RTCSMIB_NODE MIBNODE_mgmt;

extern RTCSMIB_NODE MIBNODE_mib2;
extern const RTCSMIB_NODE MIBNODE_system;
extern const RTCSMIB_NODE MIBNODE_interfaces;
extern const RTCSMIB_NODE MIBNODE_ip;
extern const RTCSMIB_NODE MIBNODE_icmp;
extern const RTCSMIB_NODE MIBNODE_tcp;
extern const RTCSMIB_NODE MIBNODE_udp;
extern const RTCSMIB_NODE MIBNODE_transmission;
extern const RTCSMIB_NODE MIBNODE_snmp;
extern const RTCSMIB_NODE MIBNODE_sysDescr;
extern const RTCSMIB_NODE MIBNODE_sysObjectID;
extern const RTCSMIB_NODE MIBNODE_sysUpTime;
extern const RTCSMIB_NODE MIBNODE_sysContact;
extern const RTCSMIB_NODE MIBNODE_sysName;
extern const RTCSMIB_NODE MIBNODE_sysLocation;
extern const RTCSMIB_NODE MIBNODE_sysServices;
extern const RTCSMIB_NODE MIBNODE_ifNumber;
extern const RTCSMIB_NODE MIBNODE_ifTable;
extern const RTCSMIB_NODE MIBNODE_ifEntry;
extern const RTCSMIB_NODE MIBNODE_ifIndex;
extern const RTCSMIB_NODE MIBNODE_ifDescr;
extern const RTCSMIB_NODE MIBNODE_ifType;
extern const RTCSMIB_NODE MIBNODE_ifMtu;
extern const RTCSMIB_NODE MIBNODE_ifSpeed;
extern const RTCSMIB_NODE MIBNODE_ifPhysAddress;
extern const RTCSMIB_NODE MIBNODE_ifAdminStatus;
extern const RTCSMIB_NODE MIBNODE_ifOperStatus;
extern const RTCSMIB_NODE MIBNODE_ifLastChange;
extern const RTCSMIB_NODE MIBNODE_ifInOctets;
extern const RTCSMIB_NODE MIBNODE_ifInUcastPkts;
extern const RTCSMIB_NODE MIBNODE_ifInNUcastPkts;
extern const RTCSMIB_NODE MIBNODE_ifInDiscards;
extern const RTCSMIB_NODE MIBNODE_ifInErrors;
extern const RTCSMIB_NODE MIBNODE_ifInUnknownProtos;
extern const RTCSMIB_NODE MIBNODE_ifOutOctets;
extern const RTCSMIB_NODE MIBNODE_ifOutUcastPkts;
extern const RTCSMIB_NODE MIBNODE_ifOutNUcastPkts;
extern const RTCSMIB_NODE MIBNODE_ifOutDiscards;
extern const RTCSMIB_NODE MIBNODE_ifOutErrors;
extern const RTCSMIB_NODE MIBNODE_ifOutQLen;
extern const RTCSMIB_NODE MIBNODE_ifSpecific;
extern const RTCSMIB_NODE MIBNODE_ipForwarding;
extern const RTCSMIB_NODE MIBNODE_ipDefaultTTL;
extern const RTCSMIB_NODE MIBNODE_ipInReceives;
extern const RTCSMIB_NODE MIBNODE_ipInHdrErrors;
extern const RTCSMIB_NODE MIBNODE_ipInAddrErrors;
extern const RTCSMIB_NODE MIBNODE_ipForwDatagrams;
extern const RTCSMIB_NODE MIBNODE_ipInUnknownProtos;
extern const RTCSMIB_NODE MIBNODE_ipInDiscards;
extern const RTCSMIB_NODE MIBNODE_ipInDelivers;
extern const RTCSMIB_NODE MIBNODE_ipOutRequests;
extern const RTCSMIB_NODE MIBNODE_ipOutDiscards;
extern const RTCSMIB_NODE MIBNODE_ipOutNoRoutes;
extern const RTCSMIB_NODE MIBNODE_ipReasmTimeout;
extern const RTCSMIB_NODE MIBNODE_ipReasmReqds;
extern const RTCSMIB_NODE MIBNODE_ipReasmOKs;
extern const RTCSMIB_NODE MIBNODE_ipReasmFails;
extern const RTCSMIB_NODE MIBNODE_ipFragOKs;
extern const RTCSMIB_NODE MIBNODE_ipFragFails;
extern const RTCSMIB_NODE MIBNODE_ipFragCreates;
extern const RTCSMIB_NODE MIBNODE_ipAddrTable;
extern const RTCSMIB_NODE MIBNODE_ipAddrEntry;
extern const RTCSMIB_NODE MIBNODE_ipAdEntAddr;
extern const RTCSMIB_NODE MIBNODE_ipAdEntIfIndex;
extern const RTCSMIB_NODE MIBNODE_ipAdEntNetMask;
extern const RTCSMIB_NODE MIBNODE_ipAdEntBcastAddr;
extern const RTCSMIB_NODE MIBNODE_ipAdEntReasmMaxSize;
extern const RTCSMIB_NODE MIBNODE_ipRouteTable;
extern const RTCSMIB_NODE MIBNODE_ipRouteEntry;
extern const RTCSMIB_NODE MIBNODE_ipRouteDest;
extern const RTCSMIB_NODE MIBNODE_ipRouteIfIndex;
extern const RTCSMIB_NODE MIBNODE_ipRouteMetric1;
extern const RTCSMIB_NODE MIBNODE_ipRouteMetric2;
extern const RTCSMIB_NODE MIBNODE_ipRouteMetric3;
extern const RTCSMIB_NODE MIBNODE_ipRouteMetric4;
extern const RTCSMIB_NODE MIBNODE_ipRouteNextHop;
extern const RTCSMIB_NODE MIBNODE_ipRouteType;
extern const RTCSMIB_NODE MIBNODE_ipRouteProto;
extern const RTCSMIB_NODE MIBNODE_ipRouteAge;
extern const RTCSMIB_NODE MIBNODE_ipRouteMask;
extern const RTCSMIB_NODE MIBNODE_ipRouteMetric5;
extern const RTCSMIB_NODE MIBNODE_ipRouteInfo;
extern const RTCSMIB_NODE MIBNODE_ipNetToMediaTable;
extern const RTCSMIB_NODE MIBNODE_ipNetToMediaEntry;
extern const RTCSMIB_NODE MIBNODE_ipNetToMediaIfIndex;
extern const RTCSMIB_NODE MIBNODE_ipNetToMediaPhysAddress;
extern const RTCSMIB_NODE MIBNODE_ipNetToMediaNetAddress;
extern const RTCSMIB_NODE MIBNODE_ipNetToMediaType;
extern const RTCSMIB_NODE MIBNODE_ipRoutingDiscards;
extern const RTCSMIB_NODE MIBNODE_icmpInMsgs;
extern const RTCSMIB_NODE MIBNODE_icmpInErrors;
extern const RTCSMIB_NODE MIBNODE_icmpInDestUnreachs;
extern const RTCSMIB_NODE MIBNODE_icmpInTimeExcds;
extern const RTCSMIB_NODE MIBNODE_icmpInParmProbs;
extern const RTCSMIB_NODE MIBNODE_icmpInSrcQuenchs;
extern const RTCSMIB_NODE MIBNODE_icmpInRedirects;
extern const RTCSMIB_NODE MIBNODE_icmpInEchos;
extern const RTCSMIB_NODE MIBNODE_icmpInEchoReps;
extern const RTCSMIB_NODE MIBNODE_icmpInTimestamps;
extern const RTCSMIB_NODE MIBNODE_icmpInTimestampReps;
extern const RTCSMIB_NODE MIBNODE_icmpInAddrMasks;
extern const RTCSMIB_NODE MIBNODE_icmpInAddrMaskReps;
extern const RTCSMIB_NODE MIBNODE_icmpOutMsgs;
extern const RTCSMIB_NODE MIBNODE_icmpOutErrors;
extern const RTCSMIB_NODE MIBNODE_icmpOutDestUnreachs;
extern const RTCSMIB_NODE MIBNODE_icmpOutTimeExcds;
extern const RTCSMIB_NODE MIBNODE_icmpOutParmProbs;
extern const RTCSMIB_NODE MIBNODE_icmpOutSrcQuenchs;
extern const RTCSMIB_NODE MIBNODE_icmpOutRedirects;
extern const RTCSMIB_NODE MIBNODE_icmpOutEchos;
extern const RTCSMIB_NODE MIBNODE_icmpOutEchoReps;
extern const RTCSMIB_NODE MIBNODE_icmpOutTimestamps;
extern const RTCSMIB_NODE MIBNODE_icmpOutTimestampReps;
extern const RTCSMIB_NODE MIBNODE_icmpOutAddrMasks;
extern const RTCSMIB_NODE MIBNODE_icmpOutAddrMaskReps;
extern const RTCSMIB_NODE MIBNODE_tcpRtoAlgorithm;
extern const RTCSMIB_NODE MIBNODE_tcpRtoMin;
extern const RTCSMIB_NODE MIBNODE_tcpRtoMax;
extern const RTCSMIB_NODE MIBNODE_tcpMaxConn;
extern const RTCSMIB_NODE MIBNODE_tcpActiveOpens;
extern const RTCSMIB_NODE MIBNODE_tcpPassiveOpens;
extern const RTCSMIB_NODE MIBNODE_tcpAttemptFails;
extern const RTCSMIB_NODE MIBNODE_tcpEstabResets;
extern const RTCSMIB_NODE MIBNODE_tcpCurrEstab;
extern const RTCSMIB_NODE MIBNODE_tcpInSegs;
extern const RTCSMIB_NODE MIBNODE_tcpOutSegs;
extern const RTCSMIB_NODE MIBNODE_tcpRetransSegs;
extern const RTCSMIB_NODE MIBNODE_tcpConnTable;
extern const RTCSMIB_NODE MIBNODE_tcpConnEntry;
extern const RTCSMIB_NODE MIBNODE_tcpConnState;
extern const RTCSMIB_NODE MIBNODE_tcpConnLocalAddress;
extern const RTCSMIB_NODE MIBNODE_tcpConnLocalPort;
extern const RTCSMIB_NODE MIBNODE_tcpConnRemAddress;
extern const RTCSMIB_NODE MIBNODE_tcpConnRemPort;
extern const RTCSMIB_NODE MIBNODE_tcpInErrs;
extern const RTCSMIB_NODE MIBNODE_tcpOutRsts;
extern const RTCSMIB_NODE MIBNODE_udpInDatagrams;
extern const RTCSMIB_NODE MIBNODE_udpNoPorts;
extern const RTCSMIB_NODE MIBNODE_udpInErrors;
extern const RTCSMIB_NODE MIBNODE_udpOutDatagrams;
extern const RTCSMIB_NODE MIBNODE_udpTable;
extern const RTCSMIB_NODE MIBNODE_udpEntry;
extern const RTCSMIB_NODE MIBNODE_udpLocalAddress;
extern const RTCSMIB_NODE MIBNODE_udpLocalPort;
extern const RTCSMIB_NODE MIBNODE_snmpInPkts;
extern const RTCSMIB_NODE MIBNODE_snmpOutPkts;
extern const RTCSMIB_NODE MIBNODE_snmpInBadVersions;
extern const RTCSMIB_NODE MIBNODE_snmpInBadCommunityNames;
extern const RTCSMIB_NODE MIBNODE_snmpInBadCommunityUses;
extern const RTCSMIB_NODE MIBNODE_snmpInASNParseErrs;
extern const RTCSMIB_NODE MIBNODE_snmpInTooBigs;
extern const RTCSMIB_NODE MIBNODE_snmpInNoSuchNames;
extern const RTCSMIB_NODE MIBNODE_snmpInBadValues;
extern const RTCSMIB_NODE MIBNODE_snmpInReadOnlys;
extern const RTCSMIB_NODE MIBNODE_snmpInGenErrs;
extern const RTCSMIB_NODE MIBNODE_snmpInTotalReqVars;
extern const RTCSMIB_NODE MIBNODE_snmpInTotalSetVars;
extern const RTCSMIB_NODE MIBNODE_snmpInGetRequests;
extern const RTCSMIB_NODE MIBNODE_snmpInGetNexts;
extern const RTCSMIB_NODE MIBNODE_snmpInSetRequests;
extern const RTCSMIB_NODE MIBNODE_snmpInGetResponses;
extern const RTCSMIB_NODE MIBNODE_snmpInTraps;
extern const RTCSMIB_NODE MIBNODE_snmpOutTooBigs;
extern const RTCSMIB_NODE MIBNODE_snmpOutNoSuchNames;
extern const RTCSMIB_NODE MIBNODE_snmpOutBadValues;
extern const RTCSMIB_NODE MIBNODE_snmpOutGenErrs;
extern const RTCSMIB_NODE MIBNODE_snmpOutGetRequests;
extern const RTCSMIB_NODE MIBNODE_snmpOutGetNexts;
extern const RTCSMIB_NODE MIBNODE_snmpOutSetRequests;
extern const RTCSMIB_NODE MIBNODE_snmpOutGetResponses;
extern const RTCSMIB_NODE MIBNODE_snmpOutTraps;
extern const RTCSMIB_NODE MIBNODE_snmpEnableAuthenTraps;

extern const RTCSMIB_VALUE MIBVALUE_mib2;
extern const RTCSMIB_VALUE MIBVALUE_system;
extern const RTCSMIB_VALUE MIBVALUE_interfaces;
extern const RTCSMIB_VALUE MIBVALUE_ip;
extern const RTCSMIB_VALUE MIBVALUE_icmp;
extern const RTCSMIB_VALUE MIBVALUE_tcp;
extern const RTCSMIB_VALUE MIBVALUE_udp;
extern const RTCSMIB_VALUE MIBVALUE_transmission;
extern const RTCSMIB_VALUE MIBVALUE_snmp;
extern const RTCSMIB_VALUE MIBVALUE_sysDescr;
extern const RTCSMIB_VALUE MIBVALUE_sysObjectID;
extern const RTCSMIB_VALUE MIBVALUE_sysUpTime;
extern const RTCSMIB_VALUE MIBVALUE_sysContact;
extern const RTCSMIB_VALUE MIBVALUE_sysName;
extern const RTCSMIB_VALUE MIBVALUE_sysLocation;
extern const RTCSMIB_VALUE MIBVALUE_sysServices;
extern const RTCSMIB_VALUE MIBVALUE_ifNumber;
extern const RTCSMIB_VALUE MIBVALUE_ifTable;
extern const RTCSMIB_VALUE MIBVALUE_ifEntry;
extern const RTCSMIB_VALUE MIBVALUE_ifIndex;
extern const RTCSMIB_VALUE MIBVALUE_ifDescr;
extern const RTCSMIB_VALUE MIBVALUE_ifType;
extern const RTCSMIB_VALUE MIBVALUE_ifMtu;
extern const RTCSMIB_VALUE MIBVALUE_ifSpeed;
extern const RTCSMIB_VALUE MIBVALUE_ifPhysAddress;
extern const RTCSMIB_VALUE MIBVALUE_ifAdminStatus;
extern const RTCSMIB_VALUE MIBVALUE_ifOperStatus;
extern const RTCSMIB_VALUE MIBVALUE_ifLastChange;
extern const RTCSMIB_VALUE MIBVALUE_ifInOctets;
extern const RTCSMIB_VALUE MIBVALUE_ifInUcastPkts;
extern const RTCSMIB_VALUE MIBVALUE_ifInNUcastPkts;
extern const RTCSMIB_VALUE MIBVALUE_ifInDiscards;
extern const RTCSMIB_VALUE MIBVALUE_ifInErrors;
extern const RTCSMIB_VALUE MIBVALUE_ifInUnknownProtos;
extern const RTCSMIB_VALUE MIBVALUE_ifOutOctets;
extern const RTCSMIB_VALUE MIBVALUE_ifOutUcastPkts;
extern const RTCSMIB_VALUE MIBVALUE_ifOutNUcastPkts;
extern const RTCSMIB_VALUE MIBVALUE_ifOutDiscards;
extern const RTCSMIB_VALUE MIBVALUE_ifOutErrors;
extern const RTCSMIB_VALUE MIBVALUE_ifOutQLen;
extern const RTCSMIB_VALUE MIBVALUE_ifSpecific;
extern const RTCSMIB_VALUE MIBVALUE_ipForwarding;
extern const RTCSMIB_VALUE MIBVALUE_ipDefaultTTL;
extern const RTCSMIB_VALUE MIBVALUE_ipInReceives;
extern const RTCSMIB_VALUE MIBVALUE_ipInHdrErrors;
extern const RTCSMIB_VALUE MIBVALUE_ipInAddrErrors;
extern const RTCSMIB_VALUE MIBVALUE_ipForwDatagrams;
extern const RTCSMIB_VALUE MIBVALUE_ipInUnknownProtos;
extern const RTCSMIB_VALUE MIBVALUE_ipInDiscards;
extern const RTCSMIB_VALUE MIBVALUE_ipInDelivers;
extern const RTCSMIB_VALUE MIBVALUE_ipOutRequests;
extern const RTCSMIB_VALUE MIBVALUE_ipOutDiscards;
extern const RTCSMIB_VALUE MIBVALUE_ipOutNoRoutes;
extern const RTCSMIB_VALUE MIBVALUE_ipReasmTimeout;
extern const RTCSMIB_VALUE MIBVALUE_ipReasmReqds;
extern const RTCSMIB_VALUE MIBVALUE_ipReasmOKs;
extern const RTCSMIB_VALUE MIBVALUE_ipReasmFails;
extern const RTCSMIB_VALUE MIBVALUE_ipFragOKs;
extern const RTCSMIB_VALUE MIBVALUE_ipFragFails;
extern const RTCSMIB_VALUE MIBVALUE_ipFragCreates;
extern const RTCSMIB_VALUE MIBVALUE_ipAddrTable;
extern const RTCSMIB_VALUE MIBVALUE_ipAddrEntry;
extern const RTCSMIB_VALUE MIBVALUE_ipAdEntAddr;
extern const RTCSMIB_VALUE MIBVALUE_ipAdEntIfIndex;
extern const RTCSMIB_VALUE MIBVALUE_ipAdEntNetMask;
extern const RTCSMIB_VALUE MIBVALUE_ipAdEntBcastAddr;
extern const RTCSMIB_VALUE MIBVALUE_ipAdEntReasmMaxSize;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteTable;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteEntry;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteDest;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteIfIndex;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric1;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric2;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric3;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric4;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteNextHop;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteType;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteProto;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteAge;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteMask;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric5;
extern const RTCSMIB_VALUE MIBVALUE_ipRouteInfo;
extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaTable;
extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaEntry;
extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaIfIndex;
extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaPhysAddress;
extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaNetAddress;
extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaType;
extern const RTCSMIB_VALUE MIBVALUE_ipRoutingDiscards;
extern const RTCSMIB_VALUE MIBVALUE_icmpInMsgs;
extern const RTCSMIB_VALUE MIBVALUE_icmpInErrors;
extern const RTCSMIB_VALUE MIBVALUE_icmpInDestUnreachs;
extern const RTCSMIB_VALUE MIBVALUE_icmpInTimeExcds;
extern const RTCSMIB_VALUE MIBVALUE_icmpInParmProbs;
extern const RTCSMIB_VALUE MIBVALUE_icmpInSrcQuenchs;
extern const RTCSMIB_VALUE MIBVALUE_icmpInRedirects;
extern const RTCSMIB_VALUE MIBVALUE_icmpInEchos;
extern const RTCSMIB_VALUE MIBVALUE_icmpInEchoReps;
extern const RTCSMIB_VALUE MIBVALUE_icmpInTimestamps;
extern const RTCSMIB_VALUE MIBVALUE_icmpInTimestampReps;
extern const RTCSMIB_VALUE MIBVALUE_icmpInAddrMasks;
extern const RTCSMIB_VALUE MIBVALUE_icmpInAddrMaskReps;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutMsgs;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutErrors;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutDestUnreachs;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutTimeExcds;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutParmProbs;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutSrcQuenchs;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutRedirects;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutEchos;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutEchoReps;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutTimestamps;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutTimestampReps;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMasks;
extern const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMaskReps;
extern const RTCSMIB_VALUE MIBVALUE_tcpRtoAlgorithm;
extern const RTCSMIB_VALUE MIBVALUE_tcpRtoMin;
extern const RTCSMIB_VALUE MIBVALUE_tcpRtoMax;
extern const RTCSMIB_VALUE MIBVALUE_tcpMaxConn;
extern const RTCSMIB_VALUE MIBVALUE_tcpActiveOpens;
extern const RTCSMIB_VALUE MIBVALUE_tcpPassiveOpens;
extern const RTCSMIB_VALUE MIBVALUE_tcpAttemptFails;
extern const RTCSMIB_VALUE MIBVALUE_tcpEstabResets;
extern const RTCSMIB_VALUE MIBVALUE_tcpCurrEstab;
extern const RTCSMIB_VALUE MIBVALUE_tcpInSegs;
extern const RTCSMIB_VALUE MIBVALUE_tcpOutSegs;
extern const RTCSMIB_VALUE MIBVALUE_tcpRetransSegs;
extern const RTCSMIB_VALUE MIBVALUE_tcpConnTable;
extern const RTCSMIB_VALUE MIBVALUE_tcpConnEntry;
extern const RTCSMIB_VALUE MIBVALUE_tcpConnState;
extern const RTCSMIB_VALUE MIBVALUE_tcpConnLocalAddress;
extern const RTCSMIB_VALUE MIBVALUE_tcpConnLocalPort;
extern const RTCSMIB_VALUE MIBVALUE_tcpConnRemAddress;
extern const RTCSMIB_VALUE MIBVALUE_tcpConnRemPort;
extern const RTCSMIB_VALUE MIBVALUE_tcpInErrs;
extern const RTCSMIB_VALUE MIBVALUE_tcpOutRsts;
extern const RTCSMIB_VALUE MIBVALUE_udpInDatagrams;
extern const RTCSMIB_VALUE MIBVALUE_udpNoPorts;
extern const RTCSMIB_VALUE MIBVALUE_udpInErrors;
extern const RTCSMIB_VALUE MIBVALUE_udpOutDatagrams;
extern const RTCSMIB_VALUE MIBVALUE_udpTable;
extern const RTCSMIB_VALUE MIBVALUE_udpEntry;
extern const RTCSMIB_VALUE MIBVALUE_udpLocalAddress;
extern const RTCSMIB_VALUE MIBVALUE_udpLocalPort;
extern const RTCSMIB_VALUE MIBVALUE_snmpInPkts;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutPkts;
extern const RTCSMIB_VALUE MIBVALUE_snmpInBadVersions;
extern const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityNames;
extern const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityUses;
extern const RTCSMIB_VALUE MIBVALUE_snmpInASNParseErrs;
extern const RTCSMIB_VALUE MIBVALUE_snmpInTooBigs;
extern const RTCSMIB_VALUE MIBVALUE_snmpInNoSuchNames;
extern const RTCSMIB_VALUE MIBVALUE_snmpInBadValues;
extern const RTCSMIB_VALUE MIBVALUE_snmpInReadOnlys;
extern const RTCSMIB_VALUE MIBVALUE_snmpInGenErrs;
extern const RTCSMIB_VALUE MIBVALUE_snmpInTotalReqVars;
extern const RTCSMIB_VALUE MIBVALUE_snmpInTotalSetVars;
extern const RTCSMIB_VALUE MIBVALUE_snmpInGetRequests;
extern const RTCSMIB_VALUE MIBVALUE_snmpInGetNexts;
extern const RTCSMIB_VALUE MIBVALUE_snmpInSetRequests;
extern const RTCSMIB_VALUE MIBVALUE_snmpInGetResponses;
extern const RTCSMIB_VALUE MIBVALUE_snmpInTraps;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutTooBigs;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutNoSuchNames;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutBadValues;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutGenErrs;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutGetRequests;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutGetNexts;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutSetRequests;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutGetResponses;
extern const RTCSMIB_VALUE MIBVALUE_snmpOutTraps;
extern const RTCSMIB_VALUE MIBVALUE_snmpEnableAuthenTraps;

boolean MIB_find_ipAddrEntry         (uint_32, pointer, pointer _PTR_);
boolean MIB_find_ifEntry             (uint_32, pointer, pointer _PTR_);
boolean MIB_find_udpEntry            (uint_32, pointer, pointer _PTR_);
boolean MIB_find_ipRouteEntry        (uint_32, pointer, pointer _PTR_);
boolean MIB_find_tcpConnEntry        (uint_32, pointer, pointer _PTR_);
boolean MIB_find_ipNetToMediaEntry   (uint_32, pointer, pointer _PTR_);

static boolean MIB_instance_ipAddrEntry         (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
static boolean MIB_instance_ifEntry             (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
static boolean MIB_instance_udpEntry            (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
static boolean MIB_instance_ipRouteEntry        (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
static boolean MIB_instance_tcpConnEntry        (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
static boolean MIB_instance_ipNetToMediaEntry   (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);

static uint_32 MIB_set_sysContact          (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_sysName             (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_sysLocation         (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ifAdminStatus       (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipForwarding        (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipDefaultTTL        (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteDest         (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteIfIndex      (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteMetric1      (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteMetric2      (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteMetric3      (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteMetric4      (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteNextHop      (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteType         (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteAge          (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteMask         (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipRouteMetric5      (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipNetToMediaIfIndex (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipNetToMediaPhysAddress(pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipNetToMediaNetAddress(pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_ipNetToMediaType    (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_tcpConnState        (pointer, uchar_ptr, uint_32);
static uint_32 MIB_set_snmpEnableAuthenTraps(pointer, uchar_ptr, uint_32);

RTCSMIB_NODE MIBNODE_mib2 = {
   1,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,
   (RTCSMIB_NODE_PTR)&MIBNODE_mgmt,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_system = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_interfaces,
   (RTCSMIB_NODE_PTR)&MIBNODE_sysDescr,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_interfaces = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_ip,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifNumber,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_ip = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipForwarding,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_icmp = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInMsgs,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_tcp = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_udp,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpRtoAlgorithm,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_udp = {
   7,

   (RTCSMIB_NODE_PTR)&MIBNODE_transmission,
   (RTCSMIB_NODE_PTR)&MIBNODE_udpInDatagrams,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_transmission = {
   10,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_snmp = {
   11,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInPkts,
   (RTCSMIB_NODE_PTR)&MIBNODE_mib2,

   0,
   NULL,
   NULL, 0, NULL, NULL
};

const RTCSMIB_NODE MIBNODE_sysDescr = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_sysObjectID,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_OCTET,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_sysDescr,
   NULL
};

const RTCSMIB_NODE MIBNODE_sysObjectID = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_sysUpTime,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_OBJECT,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_sysObjectID,
   NULL
};

const RTCSMIB_NODE MIBNODE_sysUpTime = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_sysContact,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_TimeTicks,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_sysUpTime,
   NULL
};

const RTCSMIB_NODE MIBNODE_sysContact = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_sysName,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_zero, ASN1_TYPE_OCTET,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_sysContact,
   MIB_set_sysContact
};

const RTCSMIB_NODE MIBNODE_sysName = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_sysLocation,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_zero, ASN1_TYPE_OCTET,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_sysName,
   MIB_set_sysName
};

const RTCSMIB_NODE MIBNODE_sysLocation = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_sysServices,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_zero, ASN1_TYPE_OCTET,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_sysLocation,
   MIB_set_sysLocation
};

const RTCSMIB_NODE MIBNODE_sysServices = {
   7,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_system,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_sysServices,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifNumber = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifTable,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_interfaces,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifNumber,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifTable = {
   2,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
   (RTCSMIB_NODE_PTR)&MIBNODE_interfaces,

   0,
   NULL,
   MIB_instance_zero, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifTable,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifEntry = {
   1,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifIndex,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifTable,

   0,
   MIB_find_ifEntry,
   MIB_instance_ifEntry, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifEntry,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifIndex = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifDescr,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifIndex,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifDescr = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifType,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_OCTET,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifDescr,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifType = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifMtu,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifType,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifMtu = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifSpeed,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifMtu,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifSpeed = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifPhysAddress,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Gauge,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifSpeed,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifPhysAddress = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifAdminStatus,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_OCTET,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifPhysAddress,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifAdminStatus = {
   7,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifOperStatus,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifAdminStatus,
   MIB_set_ifAdminStatus
};

const RTCSMIB_NODE MIBNODE_ifOperStatus = {
   8,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifLastChange,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOperStatus,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifLastChange = {
   9,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifInOctets,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_TimeTicks,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifLastChange,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifInOctets = {
   10,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifInUcastPkts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInOctets,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifInUcastPkts = {
   11,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifInNUcastPkts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInUcastPkts,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifInNUcastPkts = {
   12,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifInDiscards,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInNUcastPkts,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifInDiscards = {
   13,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifInErrors,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInDiscards,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifInErrors = {
   14,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifInUnknownProtos,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInErrors,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifInUnknownProtos = {
   15,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifOutOctets,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInUnknownProtos,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifOutOctets = {
   16,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifOutUcastPkts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutOctets,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifOutUcastPkts = {
   17,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifOutNUcastPkts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutUcastPkts,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifOutNUcastPkts = {
   18,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifOutDiscards,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutNUcastPkts,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifOutDiscards = {
   19,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifOutErrors,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutDiscards,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifOutErrors = {
   20,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifOutQLen,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutErrors,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifOutQLen = {
   21,

   (RTCSMIB_NODE_PTR)&MIBNODE_ifSpecific,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_Gauge,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutQLen,
   NULL
};

const RTCSMIB_NODE MIBNODE_ifSpecific = {
   22,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ifEntry, ASN1_TYPE_OBJECT,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ifSpecific,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipForwarding = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipDefaultTTL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipForwarding,
   MIB_set_ipForwarding
};

const RTCSMIB_NODE MIBNODE_ipDefaultTTL = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipInReceives,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipDefaultTTL,
   MIB_set_ipDefaultTTL
};

const RTCSMIB_NODE MIBNODE_ipInReceives = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipInHdrErrors,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInReceives,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipInHdrErrors = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipInAddrErrors,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInHdrErrors,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipInAddrErrors = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipForwDatagrams,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInAddrErrors,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipForwDatagrams = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipInUnknownProtos,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipForwDatagrams,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipInUnknownProtos = {
   7,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipInDiscards,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInUnknownProtos,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipInDiscards = {
   8,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipInDelivers,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInDiscards,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipInDelivers = {
   9,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipOutRequests,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInDelivers,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipOutRequests = {
   10,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipOutDiscards,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipOutRequests,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipOutDiscards = {
   11,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipOutNoRoutes,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipOutDiscards,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipOutNoRoutes = {
   12,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmTimeout,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipOutNoRoutes,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipReasmTimeout = {
   13,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmReqds,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmTimeout,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipReasmReqds = {
   14,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmOKs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmReqds,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipReasmOKs = {
   15,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmFails,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmOKs,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipReasmFails = {
   16,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipFragOKs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmFails,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipFragOKs = {
   17,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipFragFails,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipFragOKs,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipFragFails = {
   18,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipFragCreates,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipFragFails,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipFragCreates = {
   19,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrTable,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipFragCreates,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipAddrTable = {
   20,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteTable,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   0,
   NULL,
   MIB_instance_zero, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAddrTable,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipAddrEntry = {
   1,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntAddr,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrTable,

   0,
   MIB_find_ipAddrEntry,
   MIB_instance_ipAddrEntry, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAddrEntry,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipAdEntAddr = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntIfIndex,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ipAddrEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntAddr,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipAdEntIfIndex = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntNetMask,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ipAddrEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntIfIndex,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipAdEntNetMask = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntBcastAddr,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ipAddrEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntNetMask,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipAdEntBcastAddr = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntReasmMaxSize,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ipAddrEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntBcastAddr,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipAdEntReasmMaxSize = {
   5,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ipAddrEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntReasmMaxSize,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipRouteTable = {
   21,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaTable,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   0,
   NULL,
   MIB_instance_zero, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteTable,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipRouteEntry = {
   1,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteDest,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteTable,

   0,
   MIB_find_ipRouteEntry,
   MIB_instance_ipRouteEntry, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteEntry,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipRouteDest = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteIfIndex,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteDest,
   MIB_set_ipRouteDest
};

const RTCSMIB_NODE MIBNODE_ipRouteIfIndex = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric1,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteIfIndex,
   MIB_set_ipRouteIfIndex
};

const RTCSMIB_NODE MIBNODE_ipRouteMetric1 = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric2,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric1,
   MIB_set_ipRouteMetric1
};

const RTCSMIB_NODE MIBNODE_ipRouteMetric2 = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric3,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric2,
   MIB_set_ipRouteMetric2
};

const RTCSMIB_NODE MIBNODE_ipRouteMetric3 = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric4,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric3,
   MIB_set_ipRouteMetric3
};

const RTCSMIB_NODE MIBNODE_ipRouteMetric4 = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteNextHop,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric4,
   MIB_set_ipRouteMetric4
};

const RTCSMIB_NODE MIBNODE_ipRouteNextHop = {
   7,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteType,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteNextHop,
   MIB_set_ipRouteNextHop
};

const RTCSMIB_NODE MIBNODE_ipRouteType = {
   8,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteProto,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteType,
   MIB_set_ipRouteType
};

const RTCSMIB_NODE MIBNODE_ipRouteProto = {
   9,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteAge,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteProto,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipRouteAge = {
   10,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMask,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteAge,
   MIB_set_ipRouteAge
};

const RTCSMIB_NODE MIBNODE_ipRouteMask = {
   11,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric5,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMask,
   MIB_set_ipRouteMask
};

const RTCSMIB_NODE MIBNODE_ipRouteMetric5 = {
   12,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteInfo,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric5,
   MIB_set_ipRouteMetric5
};

const RTCSMIB_NODE MIBNODE_ipRouteInfo = {
   13,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_ipRouteEntry, ASN1_TYPE_OBJECT,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteInfo,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipNetToMediaTable = {
   22,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipRoutingDiscards,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   0,
   NULL,
   MIB_instance_zero, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaTable,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipNetToMediaEntry = {
   1,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaIfIndex,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaTable,

   0,
   MIB_find_ipNetToMediaEntry,
   MIB_instance_ipNetToMediaEntry, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaEntry,
   NULL
};

const RTCSMIB_NODE MIBNODE_ipNetToMediaIfIndex = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaPhysAddress,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipNetToMediaEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaIfIndex,
   MIB_set_ipNetToMediaIfIndex
};

const RTCSMIB_NODE MIBNODE_ipNetToMediaPhysAddress = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaNetAddress,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipNetToMediaEntry, ASN1_TYPE_OCTET,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaPhysAddress,
   MIB_set_ipNetToMediaPhysAddress
};

const RTCSMIB_NODE MIBNODE_ipNetToMediaNetAddress = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaType,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipNetToMediaEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaNetAddress,
   MIB_set_ipNetToMediaNetAddress
};

const RTCSMIB_NODE MIBNODE_ipNetToMediaType = {
   4,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_ipNetToMediaEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaType,
   MIB_set_ipNetToMediaType
};

const RTCSMIB_NODE MIBNODE_ipRoutingDiscards = {
   23,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_ip,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRoutingDiscards,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInMsgs = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInErrors,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInMsgs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInErrors = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInDestUnreachs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInErrors,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInDestUnreachs = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInTimeExcds,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInDestUnreachs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInTimeExcds = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInParmProbs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInTimeExcds,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInParmProbs = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInSrcQuenchs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInParmProbs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInSrcQuenchs = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInRedirects,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInSrcQuenchs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInRedirects = {
   7,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInEchos,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInRedirects,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInEchos = {
   8,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInEchoReps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInEchos,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInEchoReps = {
   9,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInTimestamps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInEchoReps,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInTimestamps = {
   10,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInTimestampReps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInTimestamps,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInTimestampReps = {
   11,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInAddrMasks,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInTimestampReps,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInAddrMasks = {
   12,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpInAddrMaskReps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInAddrMasks,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpInAddrMaskReps = {
   13,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutMsgs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInAddrMaskReps,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutMsgs = {
   14,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutErrors,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutMsgs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutErrors = {
   15,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutDestUnreachs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutErrors,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutDestUnreachs = {
   16,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutTimeExcds,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutDestUnreachs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutTimeExcds = {
   17,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutParmProbs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutTimeExcds,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutParmProbs = {
   18,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutSrcQuenchs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutParmProbs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutSrcQuenchs = {
   19,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutRedirects,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutSrcQuenchs,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutRedirects = {
   20,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutEchos,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutRedirects,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutEchos = {
   21,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutEchoReps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutEchos,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutEchoReps = {
   22,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutTimestamps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutEchoReps,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutTimestamps = {
   23,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutTimestampReps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutTimestamps,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutTimestampReps = {
   24,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutAddrMasks,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutTimestampReps,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutAddrMasks = {
   25,

   (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutAddrMaskReps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutAddrMasks,
   NULL
};

const RTCSMIB_NODE MIBNODE_icmpOutAddrMaskReps = {
   26,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_icmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutAddrMaskReps,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpRtoAlgorithm = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpRtoMin,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRtoAlgorithm,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpRtoMin = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpRtoMax,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRtoMin,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpRtoMax = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpMaxConn,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRtoMax,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpMaxConn = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpActiveOpens,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpMaxConn,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpActiveOpens = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpPassiveOpens,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpActiveOpens,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpPassiveOpens = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpAttemptFails,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpPassiveOpens,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpAttemptFails = {
   7,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpEstabResets,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpAttemptFails,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpEstabResets = {
   8,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpCurrEstab,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpEstabResets,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpCurrEstab = {
   9,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpInSegs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Gauge,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpCurrEstab,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpInSegs = {
   10,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpOutSegs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpInSegs,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpOutSegs = {
   11,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpRetransSegs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpOutSegs,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpRetransSegs = {
   12,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnTable,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRetransSegs,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpConnTable = {
   13,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpInErrs,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   0,
   NULL,
   MIB_instance_zero, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnTable,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpConnEntry = {
   1,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnState,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnTable,

   0,
   MIB_find_tcpConnEntry,
   MIB_instance_tcpConnEntry, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnEntry,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpConnState = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnLocalAddress,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_tcpConnEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnState,
   MIB_set_tcpConnState
};

const RTCSMIB_NODE MIBNODE_tcpConnLocalAddress = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnLocalPort,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_tcpConnEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnLocalAddress,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpConnLocalPort = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnRemAddress,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_tcpConnEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnLocalPort,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpConnRemAddress = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnRemPort,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_tcpConnEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnRemAddress,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpConnRemPort = {
   5,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_tcpConnEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnRemPort,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpInErrs = {
   14,

   (RTCSMIB_NODE_PTR)&MIBNODE_tcpOutRsts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpInErrs,
   NULL
};

const RTCSMIB_NODE MIBNODE_tcpOutRsts = {
   15,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_tcp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpOutRsts,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpInDatagrams = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_udpNoPorts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpInDatagrams,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpNoPorts = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_udpInErrors,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpNoPorts,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpInErrors = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_udpOutDatagrams,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpInErrors,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpOutDatagrams = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_udpTable,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpOutDatagrams,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpTable = {
   5,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udpEntry,
   (RTCSMIB_NODE_PTR)&MIBNODE_udp,

   0,
   NULL,
   MIB_instance_zero, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpTable,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpEntry = {
   1,

   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udpLocalAddress,
   (RTCSMIB_NODE_PTR)&MIBNODE_udpTable,

   0,
   MIB_find_udpEntry,
   MIB_instance_udpEntry, ASN1_TYPE_SEQUENCE,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpEntry,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpLocalAddress = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_udpLocalPort,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udpEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_udpEntry, ASN1_TYPE_IpAddress,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpLocalAddress,
   NULL
};

const RTCSMIB_NODE MIBNODE_udpLocalPort = {
   2,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_udpEntry,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_udpEntry, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_udpLocalPort,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInPkts = {
   1,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutPkts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInPkts,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutPkts = {
   2,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadVersions,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutPkts,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInBadVersions = {
   3,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadCommunityNames,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadVersions,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInBadCommunityNames = {
   4,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadCommunityUses,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadCommunityNames,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInBadCommunityUses = {
   5,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInASNParseErrs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadCommunityUses,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInASNParseErrs = {
   6,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTooBigs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInASNParseErrs,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInTooBigs = {
   8,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInNoSuchNames,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTooBigs,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInNoSuchNames = {
   9,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadValues,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInNoSuchNames,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInBadValues = {
   10,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInReadOnlys,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadValues,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInReadOnlys = {
   11,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGenErrs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInReadOnlys,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInGenErrs = {
   12,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTotalReqVars,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGenErrs,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInTotalReqVars = {
   13,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTotalSetVars,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTotalReqVars,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInTotalSetVars = {
   14,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGetRequests,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTotalSetVars,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInGetRequests = {
   15,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGetNexts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGetRequests,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInGetNexts = {
   16,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInSetRequests,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGetNexts,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInSetRequests = {
   17,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGetResponses,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInSetRequests,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInGetResponses = {
   18,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTraps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGetResponses,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpInTraps = {
   19,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutTooBigs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTraps,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutTooBigs = {
   20,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutNoSuchNames,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutTooBigs,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutNoSuchNames = {
   21,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutBadValues,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutNoSuchNames,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutBadValues = {
   22,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGenErrs,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutBadValues,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutGenErrs = {
   24,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGetRequests,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGenErrs,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutGetRequests = {
   25,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGetNexts,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGetRequests,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutGetNexts = {
   26,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutSetRequests,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGetNexts,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutSetRequests = {
   27,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGetResponses,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutSetRequests,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutGetResponses = {
   28,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutTraps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGetResponses,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpOutTraps = {
   29,

   (RTCSMIB_NODE_PTR)&MIBNODE_snmpEnableAuthenTraps,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ,
   NULL,
   MIB_instance_zero, ASN1_TYPE_Counter,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutTraps,
   NULL
};

const RTCSMIB_NODE MIBNODE_snmpEnableAuthenTraps = {
   30,

   NULL,
   NULL,
   (RTCSMIB_NODE_PTR)&MIBNODE_snmp,

   RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
   NULL,
   MIB_instance_zero, ASN1_TYPE_INTEGER,
   (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpEnableAuthenTraps,
   MIB_set_snmpEnableAuthenTraps
};


static boolean MIB_instance_ipAddrEntry
   (
      RTCSMIB_WALK_PTR     mib,
      uint_32              op,
      boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
      boolean _PTR_        found,
      pointer _PTR_        instance
   )
{ /* Body */
   struct {
      uchar   ipAdEntAddr[4];
   } index;

   *found = FALSE;
   *instance = NULL;

   switch (op) {

   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:

      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[0])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[1])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[2])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[3])) return FALSE;
      if (mib->inlen != 0) break;
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETNEXT:
      if (mib->inlen == 0) {
         index.ipAdEntAddr[0] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[0])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipAdEntAddr[1] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[1])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipAdEntAddr[2] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[2])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipAdEntAddr[3] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[3])) return FALSE;
         if(index.ipAdEntAddr[3] < 255)
            index.ipAdEntAddr[3]++;
      } /* Endif */
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETFIRST:
      index.ipAdEntAddr[0] = 0;
      index.ipAdEntAddr[1] = 0;
      index.ipAdEntAddr[2] = 0;
      index.ipAdEntAddr[3] = 0;
      *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
      break;
   } /* Endswitch */

   if (*found && (op != RTCSMIB_OP_SET)) {
      if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[0])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[1])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[2])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[3])) return FALSE;
   } /* Endif */

   return TRUE;
} /* Endbody */

static boolean MIB_instance_ifEntry
   (
      RTCSMIB_WALK_PTR     mib,
      uint_32              op,
      boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
      boolean _PTR_        found,
      pointer _PTR_        instance
   )
{ /* Body */
   struct {
      uint_32 ifIndex;
   } index;

   *found = FALSE;
   *instance = NULL;

   switch (op) {

   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:

      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read32(mib, &index.ifIndex)) return FALSE;
      if (mib->inlen != 0) break;
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETNEXT:
      if (mib->inlen == 0) {
         index.ifIndex = 0;
      } else {
         if (!RTCSMIB_id_read32(mib, &index.ifIndex)) return FALSE;
         if(index.ifIndex < 0xffffffff) // 4294967295
            index.ifIndex++;
      } /* Endif */
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETFIRST:
      index.ifIndex = 0;
      *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
      break;
   } /* Endswitch */

   if (*found && (op != RTCSMIB_OP_SET)) {
      if (!RTCSMIB_id_write32 (mib, index.ifIndex)) return FALSE;
   } /* Endif */

   return TRUE;
} /* Endbody */

static boolean MIB_instance_udpEntry
   (
      RTCSMIB_WALK_PTR     mib,
      uint_32              op,
      boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
      boolean _PTR_        found,
      pointer _PTR_        instance
   )
{ /* Body */
   struct {
      uchar   udpLocalAddress[4];
      uint_32 udpLocalPort;
   } index;

   *found = FALSE;
   *instance = NULL;

   switch (op) {

   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:

      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[0])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[1])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[2])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[3])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read32(mib, &index.udpLocalPort)) return FALSE;
      if (mib->inlen != 0) break;
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETNEXT:
      if (mib->inlen == 0) {
         index.udpLocalAddress[0] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[0])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.udpLocalAddress[1] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[1])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.udpLocalAddress[2] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[2])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.udpLocalAddress[3] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[3])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.udpLocalPort = 0;
      } else {
         if (!RTCSMIB_id_read32(mib, &index.udpLocalPort)) return FALSE;
         if(index.udpLocalPort < 0xffffffff) // 4294967295
            index.udpLocalPort++;
      } /* Endif */
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETFIRST:
      index.udpLocalAddress[0] = 0;
      index.udpLocalAddress[1] = 0;
      index.udpLocalAddress[2] = 0;
      index.udpLocalAddress[3] = 0;
      index.udpLocalPort = 0;
      *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
      break;
   } /* Endswitch */

   if (*found && (op != RTCSMIB_OP_SET)) {
      if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[0])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[1])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[2])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[3])) return FALSE;
      if (!RTCSMIB_id_write32 (mib, index.udpLocalPort)) return FALSE;
   } /* Endif */

   return TRUE;
} /* Endbody */

static boolean MIB_instance_ipRouteEntry
   (
      RTCSMIB_WALK_PTR     mib,
      uint_32              op,
      boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
      boolean _PTR_        found,
      pointer _PTR_        instance
   )
{ /* Body */
   struct {
      uchar   ipRouteDest[4];
   } index;

   *found = FALSE;
   *instance = NULL;

   switch (op) {

   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:

      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[0])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[1])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[2])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[3])) return FALSE;
      if (mib->inlen != 0) break;
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETNEXT:
      if (mib->inlen == 0) {
         index.ipRouteDest[0] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[0])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipRouteDest[1] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[1])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipRouteDest[2] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[2])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipRouteDest[3] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[3])) return FALSE;
         if(index.ipRouteDest[3] < 255)
            index.ipRouteDest[3]++;
      } /* Endif */
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETFIRST:
      index.ipRouteDest[0] = 0;
      index.ipRouteDest[1] = 0;
      index.ipRouteDest[2] = 0;
      index.ipRouteDest[3] = 0;
      *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
      break;
   } /* Endswitch */

   if (*found && (op != RTCSMIB_OP_SET)) {
      if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[0])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[1])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[2])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[3])) return FALSE;
   } /* Endif */

   return TRUE;
} /* Endbody */

static boolean MIB_instance_tcpConnEntry
   (
      RTCSMIB_WALK_PTR     mib,
      uint_32              op,
      boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
      boolean _PTR_        found,
      pointer _PTR_        instance
   )
{ /* Body */
   struct {
      uchar   tcpConnLocalAddress[4];
      uint_32 tcpConnLocalPort;
      uchar   tcpConnRemAddress[4];
      uint_32 tcpConnRemPort;
   } index;

   *found = FALSE;
   *instance = NULL;

   switch (op) {

   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:

      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[0])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[1])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[2])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[3])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read32(mib, &index.tcpConnLocalPort)) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[0])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[1])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[2])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[3])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read32(mib, &index.tcpConnRemPort)) return FALSE;
      if (mib->inlen != 0) break;
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETNEXT:
      if (mib->inlen == 0) {
         index.tcpConnLocalAddress[0] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[0])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnLocalAddress[1] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[1])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnLocalAddress[2] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[2])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnLocalAddress[3] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[3])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnLocalPort = 0;
      } else {
         if (!RTCSMIB_id_read32(mib, &index.tcpConnLocalPort)) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnRemAddress[0] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[0])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnRemAddress[1] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[1])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnRemAddress[2] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[2])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnRemAddress[3] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[3])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.tcpConnRemPort = 0;
      } else {
         if (!RTCSMIB_id_read32(mib, &index.tcpConnRemPort)) return FALSE;
         if(index.tcpConnRemPort < 0xffffffff) // 4294967295
            index.tcpConnRemPort++;
      } /* Endif */
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETFIRST:
      index.tcpConnLocalAddress[0] = 0;
      index.tcpConnLocalAddress[1] = 0;
      index.tcpConnLocalAddress[2] = 0;
      index.tcpConnLocalAddress[3] = 0;
      index.tcpConnLocalPort = 0;
      index.tcpConnRemAddress[0] = 0;
      index.tcpConnRemAddress[1] = 0;
      index.tcpConnRemAddress[2] = 0;
      index.tcpConnRemAddress[3] = 0;
      index.tcpConnRemPort = 0;
      *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
      break;
   } /* Endswitch */

   if (*found && (op != RTCSMIB_OP_SET)) {
      if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[0])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[1])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[2])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[3])) return FALSE;
      if (!RTCSMIB_id_write32 (mib, index.tcpConnLocalPort)) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[0])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[1])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[2])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[3])) return FALSE;
      if (!RTCSMIB_id_write32 (mib, index.tcpConnRemPort)) return FALSE;
   } /* Endif */

   return TRUE;
} /* Endbody */

static boolean MIB_instance_ipNetToMediaEntry
   (
      RTCSMIB_WALK_PTR     mib,
      uint_32              op,
      boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
      boolean _PTR_        found,
      pointer _PTR_        instance
   )
{ /* Body */
   struct {
      uint_32 ipNetToMediaIfIndex;
      uchar   ipNetToMediaNetAddress[4];
   } index;

   *found = FALSE;
   *instance = NULL;

   switch (op) {

   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:

      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read32(mib, &index.ipNetToMediaIfIndex)) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[0])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[1])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[2])) return FALSE;
      if (mib->inlen == 0) break;
      if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[3])) return FALSE;
      if (mib->inlen != 0) break;
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETNEXT:
      if (mib->inlen == 0) {
         index.ipNetToMediaIfIndex = 0;
      } else {
         if (!RTCSMIB_id_read32(mib, &index.ipNetToMediaIfIndex)) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipNetToMediaNetAddress[0] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[0])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipNetToMediaNetAddress[1] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[1])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipNetToMediaNetAddress[2] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[2])) return FALSE;
      } /* Endif */
      if (mib->inlen == 0) {
         index.ipNetToMediaNetAddress[3] = 0;
      } else {
         if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[3])) return FALSE;
         if(index.ipNetToMediaNetAddress[3] < 255)
            index.ipNetToMediaNetAddress[3]++;
      } /* Endif */
      *found = find(op, &index, instance);
      break;

   case RTCSMIB_OP_GETFIRST:
      index.ipNetToMediaIfIndex = 0;
      index.ipNetToMediaNetAddress[0] = 0;
      index.ipNetToMediaNetAddress[1] = 0;
      index.ipNetToMediaNetAddress[2] = 0;
      index.ipNetToMediaNetAddress[3] = 0;
      *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
      break;
   } /* Endswitch */

   if (*found && (op != RTCSMIB_OP_SET)) {
      if (!RTCSMIB_id_write32 (mib, index.ipNetToMediaIfIndex)) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[0])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[1])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[2])) return FALSE;
      if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[3])) return FALSE;
   } /* Endif */

   return TRUE;
} /* Endbody */


#endif


/********************************************************/

#if RTCSCFG_ENABLE_SNMP

#include <rtcs_prv.h>
#include "tcpip.h"
#include "ip_prv.h"
#include "arp_prv.h"
#include "tcp_prv.h"
#include "udp_prv.h"

extern boolean MIB_find_ifEntry(uint_32, pointer, pointer _PTR_);
extern uint_32 MIB_get_ifIndex (pointer interface);
extern uint_32 MIB_get_sysUpTime(pointer);

static uchar IpAddress[4];

static uint_32 MIB_get_snmpInPkts(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->COMMON.ST_RX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutPkts(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->COMMON.ST_TX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInBadVersions(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_BAD_VERSION);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInBadCommunityNames(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_BAD_COMMUNITY);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInASNParseErrs(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_BAD_PARSE);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInTotalReqVars(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_VAR_GETS);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInTotalSetVars(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_VAR_SETS);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInGetRequests(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_GETREQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInGetNexts(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_GETNEXTREQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInSetRequests(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_SETREQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInGetResponses(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_RESPONSE);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpInTraps(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_RX_TRAP);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutTooBigs(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_TOOBIG);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutNoSuchNames(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_NOSUCHNAME);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutBadValues(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_BADVALUE);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutGenErrs(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_GENERR);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutGetRequests(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_GETREQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutGetNexts(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_GETNEXTREQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutSetRequests(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_SETREQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutGetResponses(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_RESPONSE);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_snmpOutTraps(pointer dummy)
{
    #if RTCSCFG_ENABLE_SNMP_STATS
    SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
    return(SNMP_stats_ptr->ST_TX_TRAP);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_udpNoPorts(pointer dummy)
{
    #if RTCSCFG_ENABLE_UDP_STATS    
    UDP_STATS_PTR    UDP_stats_ptr   = UDP_stats();
    return(UDP_stats_ptr->ST_RX_NO_PORT);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_udpOutDatagrams(pointer dummy)
{
    #if RTCSCFG_ENABLE_UDP_STATS    
    UDP_STATS_PTR    UDP_stats_ptr   = UDP_stats();
    return(UDP_stats_ptr->COMMON.ST_TX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_tcpActiveOpens(pointer dummy)
{
    #if RTCSCFG_ENABLE_TCP_STATS
    TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
    return(TCP_stats_ptr->ST_CONN_ACTIVE);
    #else
    return(0);  
    #endif
}
 
static uint_32 MIB_get_tcpAttemptFails(pointer dummy)
{
    #if RTCSCFG_ENABLE_TCP_STATS
    TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
    return(TCP_stats_ptr->ST_CONN_FAILED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_tcpEstabResets(pointer dummy)
{
    #if RTCSCFG_ENABLE_TCP_STATS
    TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
    return(TCP_stats_ptr->ST_CONN_RESET);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_tcpInSegs(pointer dummy)
{
    #if RTCSCFG_ENABLE_TCP_STATS
    TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
    return(TCP_stats_ptr->COMMON.ST_RX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_tcpRetransSegs(pointer dummy)
{
    #if RTCSCFG_ENABLE_TCP_STATS
    TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
    return(TCP_stats_ptr->ST_TX_DATA_DUP);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_tcpRtoMin(pointer dummy)
{
    return(TCP_RTO_MIN);
}

static uint_32 MIB_get_tcpRtoMax(pointer dummy)
{
    return(2 * TCP_MSL);
}

static uint_32 MIB_get_icmpInMsgs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->COMMON.ST_RX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInErrors(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->COMMON.ST_RX_DISCARDED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInDestUnreachs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_DESTUNREACH);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInTimeExcds(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_TIMEEXCEED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInParmProbs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_PARMPROB);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInSrcQuenchs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_SRCQUENCH);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInRedirects(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_REDIRECT);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInEchos(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_ECHO_REQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInEchoReps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_ECHO_REPLY);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInTimestamps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_TIME_REQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInTimestampReps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_TIME_REPLY);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInAddrMasks(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_INFO_REQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpInAddrMaskReps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_RX_INFO_REPLY);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutMsgs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->COMMON.ST_TX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutErrors(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->COMMON.ST_TX_DISCARDED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutDestUnreachs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_DESTUNREACH);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutTimeExcds(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_TIMEEXCEED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutParmProbs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_PARMPROB);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutSrcQuenchs(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_SRCQUENCH);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutRedirects(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_REDIRECT);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutEchos(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_ECHO_REQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutEchoReps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_ECHO_REPLY);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutTimestamps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_TIME_REQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutTimestampReps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_TIME_REPLY);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutAddrMasks(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_INFO_REQ);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_icmpOutAddrMaskReps(pointer dummy)
{
    #if RTCSCFG_ENABLE_ICMP_STATS
    ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
    return(ICMP_stats_ptr->ST_TX_INFO_REPLY);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipReasmTimeout(pointer dummy)
{
    return(IPREASM_TTL);
}

static uint_32 MIB_get_ipInReceives(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->COMMON.ST_RX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipInHdrErrors(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_HDR_ERRORS);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipInAddrErrors(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_ADDR_ERRORS);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipForwDatagrams(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_FORWARDED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipInUnknownProtos(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_NO_PROTO);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipInDiscards(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->COMMON.ST_RX_MISSED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipInDelivers(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_DELIVERED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipOutRequests(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->COMMON.ST_TX_TOTAL);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipOutDiscards(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->COMMON.ST_TX_MISSED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipReasmReqds(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_FRAG_RECVD);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipReasmOKs(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_FRAG_REASMD);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipReasmFails(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_RX_FRAG_DISCARDED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipFragOKs(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_TX_FRAG_FRAGD);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipFragFails(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_TX_FRAG_DISCARDED);
    #else
    return(0);  
    #endif
}

static uint_32 MIB_get_ipFragCreates(pointer dummy)
{
    #if RTCSCFG_ENABLE_IP_STATS
    IP_STATS_PTR    IP_stats_ptr   = IP_stats();
    return(IP_stats_ptr->ST_TX_FRAG_SENT);
    #else
    return(0);  
    #endif
}

uint_32 MIB_get_sysUpTime (pointer dummy)
{ /* Body */
   TIME_STRUCT uptime;
   _time_get_elapsed(&uptime);
   return (uptime.SECONDS * 100) + (uptime.MILLISECONDS / 10);
} /* Endbody */

static uint_32 MIB_set_dispstr
   (
      uchar_ptr _PTR_ dest,
      uchar_ptr       varptr,
      uint_32         varlen
   )
{ /* Body */
   uchar_ptr dispstr = NULL;

   /* SIZE for DisplayString in MIB is between 0 to 255 */
   if ((varlen + 1) >= 255)
      return SNMP_ERROR_wrongLength;

   if (varlen) {
      dispstr = RTCS_mem_alloc(varlen+1);
      if (!dispstr) {
         return SNMP_ERROR_resourceUnavailable;
      } /* Endif */
      _mem_copy(varptr, dispstr, varlen);
      dispstr[varlen] = '\0';
   } /* Endif */

   if (*dest) {
      _mem_free(*dest);
   } /* Endif */

   *dest = dispstr;
   return SNMP_ERROR_noError;

} /* Endbody */

static uint_32 MIB_set_sysContact (pointer dummy, uchar_ptr varptr, uint_32 varlen)
{ /* Body */
   return MIB_set_dispstr((unsigned char **)(&MIBVALUE_sysContact.PARAM), varptr, varlen);
} /* Endbody */

static uint_32 MIB_set_sysName (pointer dummy, uchar_ptr varptr, uint_32 varlen)
{ /* Body */
   return MIB_set_dispstr((unsigned char **)(&MIBVALUE_sysName.PARAM), varptr, varlen);
} /* Endbody */

static uint_32 MIB_set_sysLocation (pointer dummy, uchar_ptr varptr, uint_32 varlen)
{ /* Body */
   return MIB_set_dispstr((unsigned char **)(&MIBVALUE_sysLocation.PARAM), varptr, varlen);
} /* Endbody */


struct MIB_get_ifNumber_struct {
   uint_32                 current_index;
   IP_CFG_STRUCT_PTR       IP_cfg_ptr;
   IP_ROUTE_DIRECT_PTR     direct;
};

static boolean MIB_get_ifNumber_test2
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   IP_ROUTE_PTR                  route = node_data;
   struct MIB_get_ifNumber_struct _PTR_ testdata = data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route && route->DIRECT &&
      route->DIRECT->DESTIF == testdata->IP_cfg_ptr->IF_LOCALHOST)
   {
      if (testdata->direct == route->DIRECT) {
         testdata->current_index++;
      } /* Endif */

      if (testdata->direct->NETIF == route->DIRECT->NETIF) {
         return TRUE;
      }
   } /* Endif */

   return FALSE;

} /* Endbody */

static boolean MIB_get_ifNumber_test1
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   IP_ROUTE_PTR                  route = node_data;
   struct MIB_get_ifNumber_struct _PTR_ testdata = data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route && route->DIRECT &&
      route->DIRECT->DESTIF == testdata->IP_cfg_ptr->IF_LOCALHOST)
   {
      testdata->direct = route->DIRECT;
      IPRADIX_walk(&testdata->IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifNumber_test2,
         testdata);
   } /* Endif */

   return FALSE;
} /* Body */

static uint_32 MIB_get_ifNumber (pointer dummy)
{ /* Body */
   IP_CFG_STRUCT_PTR                IP_cfg_ptr = RTCS_getcfg(IP);
   struct MIB_get_ifNumber_struct   testdata;

   testdata.current_index  = 0;
   testdata.IP_cfg_ptr     = IP_cfg_ptr;
   testdata.direct         = NULL;

   IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifNumber_test1, &testdata);

   return testdata.current_index;

} /* Endbody */

struct MIB_get_ifif_struct {
   uint_32                 current_index;
   IP_CFG_STRUCT_PTR       IP_cfg_ptr;
   IP_ROUTE_DIRECT_PTR     direct;
   IP_IF_PTR               interface;
   uint_32                 ifindex;
};

static boolean MIB_get_ifif_test2
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   IP_ROUTE_PTR                     route = node_data;
   struct MIB_get_ifif_struct _PTR_ testdata = data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route && route->DIRECT &&
      route->DIRECT->DESTIF == testdata->IP_cfg_ptr->IF_LOCALHOST)
   {
      if (testdata->direct == route->DIRECT) {
         testdata->current_index++;
         if (testdata->ifindex == testdata->current_index) {
            testdata->interface = testdata->direct->NETIF;
            return TRUE;
         } /* Endif */
      } /* Endif */

      if (testdata->direct->NETIF == route->DIRECT->NETIF) {
         return TRUE;
      }
   } /* Endif */

   return FALSE;

} /* Endbody */

static boolean MIB_get_ifif_test1
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   IP_ROUTE_PTR                     route = node_data;
   struct MIB_get_ifif_struct _PTR_ testdata = data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route && route->DIRECT &&
      route->DIRECT->DESTIF == testdata->IP_cfg_ptr->IF_LOCALHOST)
   {
      testdata->direct = route->DIRECT;
      IPRADIX_walk(&testdata->IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifif_test2,
         testdata);
      if (testdata->interface) {
         return TRUE;
      } /* Endif */
   } /* Endif */

   return FALSE;
} /* Body */

static pointer MIB_get_ifif (uint_32 ifindex)
{ /* Body */
   IP_CFG_STRUCT_PTR          IP_cfg_ptr = RTCS_getcfg(IP);
   struct MIB_get_ifif_struct testdata;

   testdata.current_index  = 0;
   testdata.IP_cfg_ptr     = IP_cfg_ptr;
   testdata.direct         = NULL;
   testdata.ifindex        = ifindex;
   testdata.interface      = NULL;

   IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifif_test1, &testdata);

   return testdata.interface;
} /* Endbody */

struct MIB_get_ifIndex_struct {
   uint_32                 current_index;
   IP_CFG_STRUCT_PTR       IP_cfg_ptr;
   IP_ROUTE_DIRECT_PTR     direct;
   IP_IF_PTR               interface;
   uint_32                 ifindex;
};

static boolean MIB_get_ifIndex_test2
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   IP_ROUTE_PTR                        route = node_data;
   struct MIB_get_ifIndex_struct _PTR_ testdata = data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route && route->DIRECT &&
      route->DIRECT->DESTIF == testdata->IP_cfg_ptr->IF_LOCALHOST)
   {
      if (testdata->direct == route->DIRECT) {
         testdata->current_index++;
         if (testdata->interface == testdata->direct->NETIF) {
            testdata->ifindex = testdata->current_index;
            return TRUE;
         } /* Endif */
      } /* Endif */

      if (testdata->direct->NETIF == route->DIRECT->NETIF) {
         return TRUE;
      }
   } /* Endif */

   return FALSE;

} /* Endbody */

static boolean MIB_get_ifIndex_test1
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   IP_ROUTE_PTR                        route = node_data;
   struct MIB_get_ifIndex_struct _PTR_ testdata = data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route && route->DIRECT &&
      route->DIRECT->DESTIF == testdata->IP_cfg_ptr->IF_LOCALHOST)
   {
      testdata->direct = route->DIRECT;
      IPRADIX_walk(&testdata->IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifIndex_test2,
         testdata);
      if (testdata->ifindex) {
         return TRUE;
      } /* Endif */
   } /* Endif */

   return FALSE;
} /* Body */

uint_32 MIB_get_ifIndex (pointer interface)
{ /* Body */
   IP_CFG_STRUCT_PTR             IP_cfg_ptr = RTCS_getcfg(IP);
   struct MIB_get_ifIndex_struct testdata;

   testdata.current_index  = 0;
   testdata.IP_cfg_ptr     = IP_cfg_ptr;
   testdata.direct         = NULL;
   testdata.ifindex        = 0;
   testdata.interface      = interface;

   IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifIndex_test1, &testdata);

   return testdata.ifindex;
} /* Endbody */

static uint_32 MIB_get_ifType (pointer interface) {return ((IP_IF_PTR)interface)->SNMP_IF_TYPE;}
static uint_32 MIB_get_ifMtu  (pointer interface) {return ((IP_IF_PTR)interface)->MTU;}

static uint_32 MIB_get_ifSpeed (pointer interface)
{ /* Body */
   switch (((IP_IF_PTR)interface)->SNMP_IF_TYPE) {
   case IPIFTYPE_ETHERNET:     return 10000000;
   case IPIFTYPE_FASTETHERNET: return 100000000;
   default:                    return 0;
   } /* Endswitch */
} /* Endbody */

static uchar_ptr MIB_get_ifPhysAddress (pointer interface, uint_32 _PTR_ len)
{ /* Body */
   *len = ((IP_IF_PTR)interface)->DEV_ADDRLEN;
   return ((IP_IF_PTR)interface)->DEV_ADDR;
} /* Endbody */

#if RTCSCFG_ENABLE_IPIF_STATS
static uint_32 MIB_get_ifInOctets      (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_RX_OCTETS;}
static uint_32 MIB_get_ifInUcastPkts   (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_RX_UNICAST;}
static uint_32 MIB_get_ifInNUcastPkts  (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_RX_MULTICAST + ((IP_IF_PTR)interface)->STATS.ST_RX_BROADCAST;}
static uint_32 MIB_get_ifInDiscards    (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_RX_MISSED;}
static uint_32 MIB_get_ifInErrors      (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_RX_ERRORS;}
static uint_32 MIB_get_ifOutOctets     (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_TX_OCTETS;}
static uint_32 MIB_get_ifOutUcastPkts  (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_TX_UNICAST;}
static uint_32 MIB_get_ifOutNUcastPkts (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_TX_MULTICAST + ((IP_IF_PTR)interface)->STATS.ST_TX_BROADCAST;}
static uint_32 MIB_get_ifOutDiscards   (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_TX_MISSED;}
static uint_32 MIB_get_ifOutErrors     (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_TX_ERRORS;}
#else
static uint_32 MIB_get_ifInOctets      (pointer interface) {return 0;}
static uint_32 MIB_get_ifInUcastPkts   (pointer interface) {return 0;}
static uint_32 MIB_get_ifInNUcastPkts  (pointer interface) {return 0;}
static uint_32 MIB_get_ifInDiscards    (pointer interface) {return 0;}
static uint_32 MIB_get_ifInErrors      (pointer interface) {return 0;}
static uint_32 MIB_get_ifOutOctets     (pointer interface) {return 0;}
static uint_32 MIB_get_ifOutUcastPkts  (pointer interface) {return 0;}
static uint_32 MIB_get_ifOutNUcastPkts (pointer interface) {return 0;}
static uint_32 MIB_get_ifOutDiscards   (pointer interface) {return 0;}
static uint_32 MIB_get_ifOutErrors     (pointer interface) {return 0;}
#endif

static RTCSMIB_NODE_PTR MIB_get_ifSpecific (pointer interface)
{ /* Body */
   switch (((IP_IF_PTR)interface)->SNMP_IF_TYPE) {
   default: return NULL;
   } /* Endswitch */
} /* Endbody */

boolean MIB_find_ifEntry
   (
      uint_32        op,
      pointer        index,
      pointer _PTR_  instance
   )
{ /* Body */
   uint_32           ifindex = *(uint_32_ptr)index;
   pointer           interface;

   if ((op == RTCSMIB_OP_GETNEXT) && (ifindex == 0)) {
      ifindex = 1;
   } /* Endif */

   interface = MIB_get_ifif(ifindex);
   if (!interface) {
      return FALSE;
   } /* Endif */
   *(uint_32_ptr)index = ifindex;
   *instance = interface;
   return TRUE;

} /* Endbody */

static uint_32 MIB_set_ifAdminStatus (pointer dummy, uchar_ptr varptr, uint_32 varlen)
{ /* Body */
   int_32 varval = RTCSMIB_int_read(varptr, varlen);
   switch (varval) {
   case 1:  return SNMP_ERROR_noError;
   case 2:
   case 3:  return SNMP_ERROR_inconsistentValue;
   default: return SNMP_ERROR_wrongValue;
   } /* Endswitch */
} /* Endbody */

static uint_32 MIB_get_ipForwarding (pointer dummy) {return _IP_forward ? 1 : 2;}

static uint_32 MIB_get_ipDefaultTTL (pointer dummy)
{ /* Body */
   IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
   return IP_cfg_ptr->DEFAULT_TTL;
} /* Endbody */

static uchar_ptr MIB_get_ipAdEntAddr (pointer ipaddr, uint_32 _PTR_ len)
{ /* Body */
   IP_ROUTE_DIRECT_PTR ipaddr_ptr = ipaddr;
   htonl(IpAddress, ipaddr_ptr->ADDRESS);
   *len = 4;
   return IpAddress;
} /* Endbody */

static uint_32 MIB_get_ipAdEntIfIndex (pointer ipaddr)
{ /* Body */
   IP_ROUTE_DIRECT_PTR ipaddr_ptr = ipaddr;
   return MIB_get_ifIndex(ipaddr_ptr->NETIF);
} /* Endbody */

static uchar_ptr MIB_get_ipAdEntNetMask (pointer ipaddr, uint_32 _PTR_ len)
{ /* Body */
   IP_ROUTE_DIRECT_PTR ipaddr_ptr = ipaddr;
   _ip_address         netmask;

   if (IP_get_netmask(ipaddr_ptr->NETIF, ipaddr_ptr->ADDRESS, &netmask)) {
      htonl(IpAddress, netmask);
      *len = 4;
      return IpAddress;
   } /* Endif */

   htonl(IpAddress, 0xFFFFFFFF);
   *len = 4;
   return IpAddress;
} /* Endbody */

struct MIB_get_ipRouteDest_struct {
   _ip_address             netaddr;
   _ip_address             netmask;
   pointer                 iproute;
};

static boolean MIB_get_ipRouteDest_test
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   struct MIB_get_ipRouteDest_struct _PTR_   testdata = data;
   IP_ROUTE_PTR                              route = node_data;
   IP_ROUTE_INDIRECT_PTR                     indirect;
   IP_ROUTE_DIRECT_PTR                       direct;

   if (route && route->DIRECT) {
      direct = route->DIRECT;
      do {
         if (direct == testdata->iproute) {
            testdata->netaddr = route->NODE.IP;
            testdata->netmask = route->NODE.MASK;
            return TRUE;
         } /* Endif */
         direct = direct->NEXT;
      } while (direct != route->DIRECT);
   } /* Endif */

   if (route && route->INDIRECT) {
      indirect = route->INDIRECT;
      do {
         if (indirect == testdata->iproute) {
            testdata->netaddr = route->NODE.IP;
            testdata->netmask = route->NODE.MASK;
            return TRUE;
         } /* Endif */
         indirect = indirect->NEXT;
      } while(indirect != route->INDIRECT);
   } /* Endif */

   return FALSE;
} /* Endbody */


static uchar_ptr MIB_get_ipRouteDest (pointer iproute, uint_32 _PTR_ len)
{ /* Body */
   IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
   struct MIB_get_ipRouteDest_struct   testdata;

   testdata.netaddr = INADDR_ANY;
   testdata.iproute = iproute;

   IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ipRouteDest_test, &testdata);

   htonl(IpAddress, testdata.netaddr);
   *len = 4;
   return IpAddress;
} /* Endbody */


static uint_32 MIB_get_ipRouteIfIndex (pointer iproute)
{ /* Body */
   IP_ROUTE_DIRECT_PTR                    direct = iproute;
   IP_ROUTE_INDIRECT_PTR                  indirect = iproute;
   IP_IF_PTR                              ip_interface;
   _ip_address                            if_ip;

   /* If it is a directly connected route */
   if (((IP_ROUTE_INDIRECT_PTR) iproute)->IS_DIRECT) {
      return MIB_get_ifIndex(direct->NETIF);
   } /* Endif */

   /* If it is an indirectly connected route */
   if_ip = IP_route_find(indirect->GATEWAY, IPROUTEOPT_GATE);
   if (if_ip != INADDR_ANY) {
      ip_interface = IP_find_if(if_ip);
      if (ip_interface) {
         return MIB_get_ifIndex(ip_interface);
      } /* Endif */
   } /* Endif */

   return 0;

} /* Endbody */


static uchar_ptr MIB_get_ipRouteNextHop (pointer iproute, uint_32 _PTR_ len)
{ /* Body */
   IP_ROUTE_INDIRECT_PTR iproute_ptr = iproute;
   htonl(IpAddress, iproute_ptr->GATEWAY);
   *len = 4;
   return IpAddress;
} /* Endbody */

static uint_32 MIB_get_ipRouteType (pointer iproute)
{ /* Body */
   IP_ROUTE_INDIRECT_PTR iproute_ptr = iproute;
   if (iproute_ptr->IS_DIRECT)   return 3;
   else                          return 4;
} /* Endbody */

static uchar_ptr MIB_get_ipRouteMask (pointer iproute, uint_32 _PTR_ len)
{ /* Body */
   IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
   struct MIB_get_ipRouteDest_struct   testdata;

   testdata.netmask = INADDR_ANY;
   testdata.iproute = iproute;

   IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ipRouteDest_test, &testdata);

   htonl(IpAddress, testdata.netmask);
   *len = 4;
   return IpAddress;
} /* Endbody */

static uint_32 MIB_get_ipNetToMediaIfIndex (pointer arp)
{ /* Body */
   ARP_ENTRY_PTR arp_ptr = arp;
   return MIB_get_ifIndex(arp_ptr->HEAD);
} /* Endbody */

static uchar_ptr MIB_get_ipNetToMediaPhysAddress (pointer arp, uint_32 _PTR_ len)
{ /* Body */
   ARP_ENTRY_PTR arp_ptr = arp;
   *len = 6;
   return arp_ptr->LADDR;
} /* Endbody */

static uchar_ptr MIB_get_ipNetToMediaNetAddress (pointer arp, uint_32 _PTR_ len)
{ /* Body */
   ARP_ENTRY_PTR arp_ptr = arp;
   htonl(IpAddress, arp_ptr->PADDR);
   *len = 4;
   return IpAddress;
} /* Endbody */

struct MIB_find_ipAddrEntry_struct {
   _ip_address             addr;
   IP_ROUTE_DIRECT_PTR     direct;
   _ip_address             netaddr;
   IP_IF_PTR               localhost;
};

static boolean MIB_find_ipAddrEntry_test
   (
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
   IP_ROUTE_PTR                              route = node_data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route->DIRECT && route->DIRECT->DESTIF == testdata->localhost) {
      if (route->DIRECT->ADDRESS == testdata->addr) {
         testdata->direct = route->DIRECT;
         return TRUE;
      } /* Endif */
   } /* Endif */

   return FALSE;
} /* Endbody */

static boolean MIB_find_ipAddrEntry_walk
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
   IP_ROUTE_PTR                              route = node_data;

   /* Check only leaves, which have a DESTIF of LOCALHOST */
   if (route && route->DIRECT &&
      route->DIRECT->DESTIF == testdata->localhost)
   {
      if (route->DIRECT->ADDRESS >= testdata->addr) {
         if (testdata->direct == NULL ||
            route->DIRECT->ADDRESS < testdata->direct->ADDRESS)
         {
            testdata->addr = route->DIRECT->ADDRESS;
            testdata->direct = route->DIRECT;
         } /* Endif */
      } /* Endif */
   } /* Endif */

   return FALSE;
} /* Endbody */

boolean MIB_find_ipAddrEntry
   (
      uint_32        op,
      pointer        index,
      pointer _PTR_  instance
   )
{ /* Body */
   IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
   struct MIB_find_ipAddrEntry_struct  testdata;

   struct {
      uchar   ipAdEntAddr[4];
   } _PTR_ realindex = index;

   testdata.addr        = ntohl(realindex->ipAdEntAddr);
   testdata.localhost   = IP_cfg_ptr->IF_LOCALHOST;
   testdata.direct      = NULL;

   switch (op) {
   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:
      IPRADIX_findbest(&IP_cfg_ptr->ROUTE_ROOT.NODE, testdata.addr,
         MIB_find_ipAddrEntry_test, &testdata);
      break;

   case RTCSMIB_OP_GETNEXT:
      IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_find_ipAddrEntry_walk, &testdata);
      break;
   } /* Endswitch */

   if (!testdata.direct) {
      return FALSE;
   } /* Endif */

   htonl(realindex->ipAdEntAddr, testdata.direct->ADDRESS);
   *instance = testdata.direct;
   return TRUE;

} /* Endbody */

static boolean MIB_find_ipRouteEntry_test1
   (
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
   IP_ROUTE_PTR                              route = node_data;

   if (route->NODE.IP == testdata->addr) {
      testdata->direct = route->DIRECT;
      if (testdata->direct == NULL) {
         testdata->direct = (IP_ROUTE_DIRECT_PTR)((void _PTR_)route->INDIRECT);
         return TRUE;
      } /* Endif */
   } /* Endif */

   return FALSE;
} /* Enbody */

static boolean MIB_find_ipRouteEntry_walk1
   (
      _ip_address    node_ip,
      _ip_address    node_mask,
      pointer        node_data,
      pointer        data
   )
{ /* Body */
   struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
   IP_ROUTE_PTR                              route = node_data;

   if (route) {
      if (node_ip >= testdata->addr) {
         if (testdata->direct == NULL || node_ip < testdata->netaddr) {
            testdata->netaddr = node_ip;
            testdata->direct = route->DIRECT;
            if (testdata->direct == NULL) {
               testdata->direct =
                  (IP_ROUTE_DIRECT_PTR)((void _PTR_)route->INDIRECT);
            } /* Endif */
         }  /* Endif */
      } /* Endif */
   } /* Endif */

   return FALSE;
} /* Endbody */

boolean MIB_find_ipRouteEntry
   (
      uint_32        op,
      pointer        index,
      pointer _PTR_  instance
   )
{ /* Body */
   IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
   struct MIB_find_ipAddrEntry_struct  testdata;
   struct {
      uchar   ipRouteDest[4];
   } _PTR_ realindex = index;

   testdata.addr = ntohl(realindex->ipRouteDest);
   testdata.direct = NULL;
   testdata.netaddr = INADDR_ANY;

   switch (op) {
   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:
      /* CR 1822 */
      /*
      IPRADIX_findbest(&IP_cfg_ptr->ROUTE_ROOT.NODE, testdata.addr,
         MIB_find_ipRouteEntry_test1, &testdata);
      break;
      */
      /* End CR 1822 */

   case RTCSMIB_OP_GETNEXT:
      IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_find_ipRouteEntry_walk1, &testdata);
      break;
   } /* Endswitch */

   if (!testdata.direct) {
      return FALSE;
   } /* Endif */

   htonl(realindex->ipRouteDest, testdata.netaddr);
   *instance = testdata.direct;
   return TRUE;

} /* Endbody */

boolean MIB_find_ipNetToMediaEntry
   (
      uint_32        op,
      pointer        index,
      pointer _PTR_  instance
   )
{ /* Body */
   IP_IF_PTR         interface;
   ARP_CFG_PTR       arp_cfg_ptr;
   ARP_ENTRY_PTR     arp_ptr, search_ptr;
   uint_32           ifindex, maxindex, arphash;
   _ip_address       netaddr;
   struct {
      uint_32 ipNetToMediaIfIndex;
      uchar   ipNetToMediaNetAddress[4];
   } _PTR_ realindex = index;

   ifindex = realindex->ipNetToMediaIfIndex;
   netaddr = ntohl(realindex->ipNetToMediaNetAddress);
   maxindex = MIB_get_ifNumber(NULL);

   arp_ptr = NULL;
   switch (op) {
   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:
      interface = MIB_get_ifif(ifindex);
      if (!interface) {
         return FALSE;
      } /* Endif */
      arp_cfg_ptr = interface->ARP;
      if (!arp_cfg_ptr) {
         return FALSE;
      } /* Endif */
      for (arp_ptr = arp_cfg_ptr->CACHE[ARPCACHE_HASH(netaddr)];
           arp_ptr;
           arp_ptr = arp_ptr->NEXT) {
         if (arp_ptr->PADDR == netaddr) {
            break;
         } /* Endif */
      } /* Endfor */
      break;

   case RTCSMIB_OP_GETNEXT:
      for (; ifindex <= maxindex; ifindex++) {
         interface = MIB_get_ifif(ifindex);
         if (!interface) {
            continue;
         } /* Endif */
         arp_cfg_ptr = interface->ARP;
         if (!arp_cfg_ptr) {
            continue;
         } /* Endif */

         for (arphash = 0; arphash < ARPCACHE_SIZE; arphash++) {
            for (search_ptr = arp_cfg_ptr->CACHE[arphash];
                 search_ptr;
                 search_ptr = search_ptr->NEXT) {
               if (search_ptr->PADDR >= netaddr) {
                  if (arp_ptr == NULL) {
                     arp_ptr = search_ptr;
                  } else if (search_ptr->PADDR < arp_ptr->PADDR) {
                     arp_ptr = search_ptr;
                  } /* Endif */
               } /* Endif */
            } /* Endfor */
         } /* Endfor */

         if (arp_ptr) {
            break;
         } /* Endif */

      } /* Endfor */
      break;

   } /* Endswitch */

   if (!arp_ptr) {
      return FALSE;
   } /* Endif */

   realindex->ipNetToMediaIfIndex = ifindex;
   htonl(realindex->ipNetToMediaNetAddress, arp_ptr->PADDR);
   *instance = arp_ptr;
   return TRUE;

} /* Endbody */

uint_32 MIB_set_ipForwarding (pointer dummy, uchar_ptr varptr, uint_32 varlen)
{ /* Body */
   int_32 varval = RTCSMIB_int_read(varptr, varlen);
   switch (varval) {
   case 1: _IP_forward = TRUE;  return SNMP_ERROR_noError;
   case 2: _IP_forward = FALSE; return SNMP_ERROR_noError;
   default: return SNMP_ERROR_wrongValue;
   } /* Endswitch */
} /* Endbody */

uint_32 MIB_set_ipDefaultTTL (pointer dummy, uchar_ptr varptr, uint_32 varlen)
{ /* Body */
   IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
   int_32            varval = RTCSMIB_int_read(varptr, varlen);

   if (varval >= 1 && varval <= 255) {
      IP_cfg_ptr->DEFAULT_TTL = varval;
      return SNMP_ERROR_noError;
   } else {
      return SNMP_ERROR_wrongValue;
   } /* Endif */
} /* Endbody */

uint_32 MIB_set_ipRouteDest            (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteIfIndex         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteMetric1         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteMetric2         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteMetric3         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteMetric4         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteMetric5         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteNextHop         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteType            (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteAge             (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipRouteMask            (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipNetToMediaIfIndex    (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipNetToMediaPhysAddress(pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipNetToMediaNetAddress (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
uint_32 MIB_set_ipNetToMediaType       (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}

static uint_32 MIB_get_tcpPassiveOpens (pointer dummy)
{ /* Body */
#if RTCSCFG_ENABLE_TCP_STATS
   TCP_CFG_STRUCT_PTR   TCP_cfg_ptr = RTCS_getcfg(TCP);
   TCB_STRUCT_PTR       tcb_ptr;
   uint_32              var;

   var = TCP_cfg_ptr->STATS.ST_CONN_PASSIVE;
   for (tcb_ptr = TCP_cfg_ptr->TCBhead;
        tcb_ptr;
        tcb_ptr = tcb_ptr->next) {
      if (tcb_ptr->state == LISTEN) var--;
   } /* Endfor */
   return var;
#else
   return 0;
#endif
} /* Endbody */

static uint_32 MIB_get_tcpCurrEstab (pointer dummy)
{ /* Body */
   TCP_CFG_STRUCT_PTR   TCP_cfg_ptr = RTCS_getcfg(TCP);
   TCB_STRUCT_PTR       tcb_ptr;
   uint_32              var;

   var = 0;
   for (tcb_ptr = TCP_cfg_ptr->TCBhead;
        tcb_ptr;
        tcb_ptr = tcb_ptr->next) {
      if (tcb_ptr->state == ESTABLISHED) var++;
   } /* Endfor */
   return var;

} /* Endbody */

static  uint_32 MIB_get_tcpOutSegs (pointer dummy)
{ /* Body */
 #if RTCSCFG_ENABLE_TCP_STATS
  TCP_STATS_PTR TCP_stats_ptr = TCP_stats();
   return TCP_stats_ptr->COMMON.ST_TX_TOTAL - TCP_stats_ptr->ST_TX_DATA_DUP;
#else
   return 0;
#endif
} /* Endbody */

static uint_32 MIB_get_tcpConnState (pointer tcb)
{ /* Body */
   switch (((TCB_STRUCT_PTR)tcb)->state) {
   case LISTEN:         return 2;
   case SYN_SENT:       return 3;
   case SYN_RECEIVED:   return 4;
   case ESTABLISHED:    return 5;
   case FINWAIT_1:      return 6;
   case FINWAIT_2:      return 7;
   case CLOSE_WAIT:     return 8;
   case LAST_ACK:       return 9;
   case CLOSING:        return 10;
   case TIME_WAIT:      return 11;
   default:             return 1;
   } /* Endswitch */
} /* Endbody */

static uchar_ptr MIB_get_tcpConnLocalAddress (pointer tcb, uint_32 _PTR_ len)
{ /* Body */
   TCB_STRUCT_PTR tcb_ptr = tcb;
   htonl(IpAddress, tcb_ptr->local_host);
   *len = 4;
   return IpAddress;
} /* Endbody */

static uint_32 MIB_get_tcpConnLocalPort (pointer tcb)
{ /* Body */
   return ((TCB_STRUCT_PTR)tcb)->local_port;
} /* Endbody */

static uchar_ptr MIB_get_tcpConnRemAddress (pointer tcb, uint_32 _PTR_ len)
{ /* Body */
   TCB_STRUCT_PTR tcb_ptr = tcb;
   htonl(IpAddress, tcb_ptr->remote_host);
   *len = 4;
   return IpAddress;
} /* Endbody */

static uint_32 MIB_get_tcpConnRemPort (pointer tcb)
{ /* Body */
   return ((TCB_STRUCT_PTR)tcb)->remote_port;
} /* Endbody */

boolean MIB_find_tcpConnEntry
   (
      uint_32        op,
      pointer        index,
      pointer _PTR_  instance
   )
{ /* Body */
   TCP_CFG_STRUCT_PTR   TCP_cfg_ptr = RTCS_getcfg(TCP);
   TCB_STRUCT_PTR       tcb_ptr, search_ptr;
   _ip_address          locaddr, remaddr;
   uint_16              locport, remport;
   struct {
      uchar   tcpConnLocalAddress[4];
      uint_32 tcpConnLocalPort;
      uchar   tcpConnRemAddress[4];
      uint_32 tcpConnRemPort;
   } _PTR_ realindex = index;

   locaddr = ntohl(realindex->tcpConnLocalAddress);
   locport = realindex->tcpConnLocalPort;
   remaddr = ntohl(realindex->tcpConnRemAddress);
   remport = realindex->tcpConnRemPort;

   tcb_ptr = NULL;
   switch (op) {
   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:
      for (tcb_ptr = TCP_cfg_ptr->TCBhead;
           tcb_ptr;
           tcb_ptr = tcb_ptr->next) {

         if ((tcb_ptr->local_host  == locaddr)
          && (tcb_ptr->local_port  == locport)
          && (tcb_ptr->remote_host == remaddr)
          && (tcb_ptr->remote_port == remport)) {

            break;
         } /* Endif */
      } /* Endfor */
      break;

   case RTCSMIB_OP_GETNEXT:
      for (search_ptr = TCP_cfg_ptr->TCBhead;
           search_ptr;
           search_ptr = search_ptr->next) {

         if ( (search_ptr->local_host >  locaddr)

          || ((search_ptr->local_host == locaddr)
           && (search_ptr->local_port >  locport))

          || ((search_ptr->local_host  == locaddr)
           && (search_ptr->local_port  == locport)
           && (search_ptr->remote_host >  remaddr))

          || ((search_ptr->local_host  == locaddr)
           && (search_ptr->local_port  == locport)
           && (search_ptr->remote_host == remaddr)
           && (search_ptr->remote_port >= remport)) ) {

            if (tcb_ptr == NULL) {
               tcb_ptr = search_ptr;
            } else if ( (search_ptr->local_host <  tcb_ptr->local_host)

                    || ((search_ptr->local_host == tcb_ptr->local_host)
                     && (search_ptr->local_port <  tcb_ptr->local_port))

                    || ((search_ptr->local_host  == tcb_ptr->local_host)
                     && (search_ptr->local_port  == tcb_ptr->local_port)
                     && (search_ptr->remote_host <  tcb_ptr->remote_host))

                    || ((search_ptr->local_host  == tcb_ptr->local_host)
                     && (search_ptr->local_port  == tcb_ptr->local_port)
                     && (search_ptr->remote_host == tcb_ptr->remote_host)
                     && (search_ptr->remote_port <  tcb_ptr->remote_port)) ) {
               tcb_ptr = search_ptr;
            } /* Endif */
         } /* Endif */
      } /* Endfor */
      break;

   } /* Endswitch */

   if (!tcb_ptr) {
      return FALSE;
   } /* Endif */

   htonl(realindex->tcpConnLocalAddress, tcb_ptr->local_host);
   realindex->tcpConnLocalPort = tcb_ptr->local_port;
   htonl(realindex->tcpConnRemAddress, tcb_ptr->remote_host);
   realindex->tcpConnRemPort = tcb_ptr->remote_port;
   *instance = tcb_ptr;
   return TRUE;

} /* Endbody */

static uint_32 MIB_set_tcpConnState(pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}

static uint_32 MIB_get_udpInDatagrams (pointer dummy)
{ /* Body */
#if RTCSCFG_ENABLE_UDP_STATS
   UDP_STATS_PTR UDP_stats_ptr = UDP_stats();
   return UDP_stats_ptr->COMMON.ST_RX_TOTAL - UDP_stats_ptr->COMMON.ST_RX_DISCARDED;
#else
   return 0;
#endif
} /* Endbody */

static uint_32 MIB_get_udpInErrors (pointer dummy)
{ /* Body */
 #if RTCSCFG_ENABLE_UDP_STATS
  UDP_STATS_PTR UDP_stats_ptr = UDP_stats();
   return UDP_stats_ptr->COMMON.ST_RX_DISCARDED - UDP_stats_ptr->ST_RX_NO_PORT;
#else
   return 0;
#endif
} /* Endbody */

static uchar_ptr MIB_get_udpLocalAddress (pointer ucb, uint_32 _PTR_ len)
{ /* Body */
   UCB_STRUCT_PTR ucb_ptr = ucb;
   htonl(IpAddress, ucb_ptr->IPADDR);
   *len = 4;
   return IpAddress;
} /* Endbody */

static uint_32 MIB_get_udpLocalPort (pointer ucb)
{ /* Body */
   return ((UCB_STRUCT_PTR)ucb)->PORT;
} /* Endbody */

boolean MIB_find_udpEntry
   (
      uint_32        op,
      pointer        index,
      pointer _PTR_  instance
   )
{ /* Body */
   UDP_CFG_STRUCT_PTR   UDP_cfg_ptr = RTCS_getcfg(UDP);
   UCB_STRUCT_PTR       ucb_ptr, search_ptr;
   _ip_address          locaddr;
   uint_16              locport;
   struct {
      uchar   udpLocalAddress[4];
      uint_32 udpLocalPort;
   } _PTR_ realindex = index;

   locaddr = ntohl(realindex->udpLocalAddress);
   locport = realindex->udpLocalPort;

   ucb_ptr = NULL;
   switch (op) {
   case RTCSMIB_OP_GET:
   case RTCSMIB_OP_SET:
      RTCS_LIST_SEARCH(UDP_cfg_ptr->OPEN_UCB_HEAD, search_ptr) {
         if ((search_ptr->IPADDR == locaddr)
          && (search_ptr->PORT   == locport)) {
            ucb_ptr = search_ptr;
            break;
         } /* Endif */
      } /* End SEARCH */

      RTCS_LIST_SEARCH(UDP_cfg_ptr->LBOUND_UCB_HEAD, search_ptr) {
         if ((search_ptr->IPADDR == locaddr)
          && (search_ptr->PORT   == locport)) {
            ucb_ptr = search_ptr;
            break;
         } /* Endif */
      } /* End SEARCH */

      RTCS_LIST_SEARCH(UDP_cfg_ptr->BOUND_UCB_HEAD, search_ptr) {
         if ((search_ptr->IPADDR == locaddr)
          && (search_ptr->PORT   == locport)) {
            ucb_ptr = search_ptr;
            break;
         } /* Endif */
      } /* End SEARCH */
      break;
   case RTCSMIB_OP_GETNEXT:
      RTCS_LIST_SEARCH(UDP_cfg_ptr->OPEN_UCB_HEAD, search_ptr) {
         if ((search_ptr->IPADDR >  locaddr)
         || ((search_ptr->IPADDR == locaddr)
          && (search_ptr->PORT   >= locport))) {
            if (ucb_ptr == NULL) {
               ucb_ptr = search_ptr;
            } else if ((search_ptr->IPADDR <  ucb_ptr->IPADDR)
                   || ((search_ptr->IPADDR == ucb_ptr->IPADDR)
                    && (search_ptr->PORT   <  ucb_ptr->PORT))) {
               ucb_ptr = search_ptr;
            } /* Endif */
         } /* Endif */
      } /* End SEARCH */

      RTCS_LIST_SEARCH(UDP_cfg_ptr->LBOUND_UCB_HEAD, search_ptr) {
         if ((search_ptr->IPADDR >  locaddr)
         || ((search_ptr->IPADDR == locaddr)
          && (search_ptr->PORT   >= locport))) {
            if (ucb_ptr == NULL) {
               ucb_ptr = search_ptr;
            } else if ((search_ptr->IPADDR <  ucb_ptr->IPADDR)
                   || ((search_ptr->IPADDR == ucb_ptr->IPADDR)
                    && (search_ptr->PORT   <  ucb_ptr->PORT))) {
               ucb_ptr = search_ptr;
            } /* Endif */
         } /* Endif */
      } /* End SEARCH */

      RTCS_LIST_SEARCH(UDP_cfg_ptr->BOUND_UCB_HEAD, search_ptr) {
         if ((search_ptr->IPADDR >  locaddr)
         || ((search_ptr->IPADDR == locaddr)
          && (search_ptr->PORT   >= locport))) {
            if (ucb_ptr == NULL) {
               ucb_ptr = search_ptr;
            } else if ((search_ptr->IPADDR <  ucb_ptr->IPADDR)
                   || ((search_ptr->IPADDR == ucb_ptr->IPADDR)
                    && (search_ptr->PORT   <  ucb_ptr->PORT))) {
               ucb_ptr = search_ptr;
            } /* Endif */
         } /* Endif */
      } /* End SEARCH */

      break;
   } /* Endswitch */

   if (!ucb_ptr) {
      return FALSE;
   } /* Endif */

   htonl(realindex->udpLocalAddress, ucb_ptr->IPADDR);
   realindex->udpLocalPort = ucb_ptr->PORT;
   *instance = ucb_ptr;
   return TRUE;

} /* Endbody */

uint_32 MIB_set_snmpEnableAuthenTraps
   (
      pointer     dummy,
      uchar_ptr   varptr,
      uint_32     varlen
   )
{ /* Body */
   /* CR 850 */
   int_32 varval = RTCSMIB_int_read(varptr, varlen);
   /* End CR 850 */
   switch (varval) {
   case 1:  return SNMP_ERROR_inconsistentValue;
   case 2:  return SNMP_ERROR_noError;
   default: return SNMP_ERROR_wrongValue;
   } /* Endswitch */
} /* Endbody */

/****************************************************************************/

const RTCSMIB_VALUE MIBVALUE_mib2 = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

/* system */
const RTCSMIB_VALUE MIBVALUE_system = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_sysDescr = {
    RTCSMIB_NODETYPE_DISPSTR_PTR,
    (void _PTR_)SNMPCFG_SYSDESCR
};

const RTCSMIB_VALUE MIBVALUE_sysObjectID = {
    RTCSMIB_NODETYPE_OID_PTR,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_sysUpTime = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_sysUpTime
};

const RTCSMIB_VALUE MIBVALUE_sysContact = {
    RTCSMIB_NODETYPE_DISPSTR_PTR,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_sysName = {
    RTCSMIB_NODETYPE_DISPSTR_PTR,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_sysLocation = {
    RTCSMIB_NODETYPE_DISPSTR_PTR,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_sysServices = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)SNMPCFG_SYSSERVICES
};

/* interfaces */
const RTCSMIB_VALUE MIBVALUE_interfaces = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifNumber = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifNumber
};

const RTCSMIB_VALUE MIBVALUE_ifTable = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifEntry = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifIndex = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifDescr = {
    RTCSMIB_NODETYPE_DISPSTR_PTR,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifType = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifType
};

const RTCSMIB_VALUE MIBVALUE_ifMtu = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifMtu
};

const RTCSMIB_VALUE MIBVALUE_ifSpeed = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifSpeed
};

const RTCSMIB_VALUE MIBVALUE_ifPhysAddress = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ifPhysAddress
};

const RTCSMIB_VALUE MIBVALUE_ifAdminStatus = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)1
};

const RTCSMIB_VALUE MIBVALUE_ifOperStatus = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)1
};

const RTCSMIB_VALUE MIBVALUE_ifLastChange = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifInOctets = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInOctets
};

const RTCSMIB_VALUE MIBVALUE_ifInUcastPkts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInUcastPkts
};

const RTCSMIB_VALUE MIBVALUE_ifInNUcastPkts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInNUcastPkts
};

const RTCSMIB_VALUE MIBVALUE_ifInDiscards = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInDiscards
};

const RTCSMIB_VALUE MIBVALUE_ifInErrors = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInErrors
};

const RTCSMIB_VALUE MIBVALUE_ifInUnknownProtos = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifOutOctets = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutOctets
};

const RTCSMIB_VALUE MIBVALUE_ifOutUcastPkts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutUcastPkts
};

const RTCSMIB_VALUE MIBVALUE_ifOutNUcastPkts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutNUcastPkts
};

const RTCSMIB_VALUE MIBVALUE_ifOutDiscards = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutDiscards
};

const RTCSMIB_VALUE MIBVALUE_ifOutErrors = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutErrors
};

const RTCSMIB_VALUE MIBVALUE_ifOutQLen = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ifSpecific = {
    RTCSMIB_NODETYPE_OID_FN,
    (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ifSpecific
};

/* IP */
const RTCSMIB_VALUE MIBVALUE_ip = {
    RTCSMIB_NODETYPE_INT_CONST,
    (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ifSpecific
};

const RTCSMIB_VALUE MIBVALUE_ipForwarding = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ipForwarding
};

const RTCSMIB_VALUE MIBVALUE_ipDefaultTTL = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ipDefaultTTL
};

const RTCSMIB_VALUE MIBVALUE_ipInReceives = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInReceives
};

const RTCSMIB_VALUE MIBVALUE_ipInHdrErrors = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInHdrErrors
};

const RTCSMIB_VALUE MIBVALUE_ipInAddrErrors = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInAddrErrors
};

const RTCSMIB_VALUE MIBVALUE_ipForwDatagrams = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipForwDatagrams
};

const RTCSMIB_VALUE MIBVALUE_ipInUnknownProtos = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInUnknownProtos
};

const RTCSMIB_VALUE MIBVALUE_ipInDelivers = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInDelivers
};

const RTCSMIB_VALUE MIBVALUE_ipOutRequests = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipOutRequests
};

const RTCSMIB_VALUE MIBVALUE_ipOutDiscards = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipOutDiscards
};

const RTCSMIB_VALUE MIBVALUE_ipOutNoRoutes = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipReasmTimeout = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmTimeout
};

const RTCSMIB_VALUE MIBVALUE_ipReasmReqds = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmReqds
};

const RTCSMIB_VALUE MIBVALUE_ipReasmOKs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmOKs
};

const RTCSMIB_VALUE MIBVALUE_ipReasmFails = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmFails
};

const RTCSMIB_VALUE MIBVALUE_ipFragOKs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipFragOKs
};

const RTCSMIB_VALUE MIBVALUE_ipFragFails = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipFragFails
};

const RTCSMIB_VALUE MIBVALUE_ipFragCreates = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipFragCreates
};

const RTCSMIB_VALUE MIBVALUE_ipAddrTable = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipAddrEntry = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipAdEntAddr = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipAdEntAddr
};

const RTCSMIB_VALUE MIBVALUE_ipAdEntIfIndex = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipAdEntIfIndex
};

const RTCSMIB_VALUE MIBVALUE_ipAdEntNetMask = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipAdEntNetMask
};

const RTCSMIB_VALUE MIBVALUE_ipAdEntBcastAddr = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)1
};

const RTCSMIB_VALUE MIBVALUE_ipAdEntReasmMaxSize = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)65535
};

const RTCSMIB_VALUE MIBVALUE_ipRouteTable = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteEntry = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteDest = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipRouteDest
};

const RTCSMIB_VALUE MIBVALUE_ipRouteIfIndex = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipRouteIfIndex
};

const RTCSMIB_VALUE MIBVALUE_ipRouteMetric1 = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteMetric2 = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteMetric3 = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteMetric4 = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteNextHop = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipRouteNextHop
};

const RTCSMIB_VALUE MIBVALUE_ipRouteType = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipRouteType
};

const RTCSMIB_VALUE MIBVALUE_ipRouteProto = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)2
};

const RTCSMIB_VALUE MIBVALUE_ipRouteAge = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteMask = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipRouteMask
};

const RTCSMIB_VALUE MIBVALUE_ipRouteMetric5 = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRouteInfo = {
    RTCSMIB_NODETYPE_OID_PTR,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipNetToMediaIfIndex = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipNetToMediaIfIndex
};

const RTCSMIB_VALUE MIBVALUE_ipNetToMediaPhysAddress = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipNetToMediaPhysAddress
};

const RTCSMIB_VALUE MIBVALUE_ipNetToMediaNetAddress = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipNetToMediaNetAddress
};

const RTCSMIB_VALUE MIBVALUE_ipNetToMediaType = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)3
};

const RTCSMIB_VALUE MIBVALUE_ipNetToMediaTable = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipNetToMediaEntry = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_ipRoutingDiscards = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_icmp = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_icmpInMsgs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInReceives
};

const RTCSMIB_VALUE MIBVALUE_icmpInErrors = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInErrors
};

const RTCSMIB_VALUE MIBVALUE_icmpInDestUnreachs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInDestUnreachs
};

const RTCSMIB_VALUE MIBVALUE_icmpInTimeExcds = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInTimeExcds
};

const RTCSMIB_VALUE MIBVALUE_icmpInParmProbs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInParmProbs
};

const RTCSMIB_VALUE MIBVALUE_icmpInSrcQuenchs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInSrcQuenchs
};

const RTCSMIB_VALUE MIBVALUE_icmpInRedirects = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInRedirects
};

const RTCSMIB_VALUE MIBVALUE_icmpInEchos = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInEchos
};

const RTCSMIB_VALUE MIBVALUE_icmpInEchoReps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInEchoReps
};

const RTCSMIB_VALUE MIBVALUE_icmpInTimestamps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInTimestamps
};

const RTCSMIB_VALUE MIBVALUE_icmpInTimestampReps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInTimestampReps
};

const RTCSMIB_VALUE MIBVALUE_icmpInAddrMasks = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInAddrMasks
};

const RTCSMIB_VALUE MIBVALUE_icmpInAddrMaskReps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInAddrMaskReps
};

const RTCSMIB_VALUE MIBVALUE_icmpOutMsgs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutMsgs
};

const RTCSMIB_VALUE MIBVALUE_icmpOutErrors = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutErrors
};

const RTCSMIB_VALUE MIBVALUE_icmpOutDestUnreachs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutDestUnreachs
};

const RTCSMIB_VALUE MIBVALUE_icmpOutTimeExcds = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutTimeExcds
};

const RTCSMIB_VALUE MIBVALUE_icmpOutParmProbs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutParmProbs
};

const RTCSMIB_VALUE MIBVALUE_icmpOutSrcQuenchs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutSrcQuenchs
};

const RTCSMIB_VALUE MIBVALUE_icmpOutRedirects = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutRedirects
};

const RTCSMIB_VALUE MIBVALUE_icmpOutEchos = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutEchos
};

const RTCSMIB_VALUE MIBVALUE_icmpOutEchoReps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutEchoReps
};

const RTCSMIB_VALUE MIBVALUE_icmpOutTimestamps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutTimestamps
};

const RTCSMIB_VALUE MIBVALUE_icmpOutTimestampReps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutTimestampReps
};

const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMasks = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutAddrMasks
};

const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMaskReps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutAddrMaskReps
};

const RTCSMIB_VALUE MIBVALUE_tcp = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_tcpRtoAlgorithm = {
    RTCSMIB_NODETYPE_UINT_CONST,
    (void _PTR_)4
};

const RTCSMIB_VALUE MIBVALUE_tcpRtoMin = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpRtoMin
};

const RTCSMIB_VALUE MIBVALUE_tcpRtoMax = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpRtoMax 
};

const RTCSMIB_VALUE MIBVALUE_tcpMaxConn = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_tcpActiveOpens = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpActiveOpens
};

const RTCSMIB_VALUE MIBVALUE_tcpPassiveOpens = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpPassiveOpens
};

const RTCSMIB_VALUE MIBVALUE_tcpAttemptFails = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpAttemptFails
};

const RTCSMIB_VALUE MIBVALUE_tcpEstabResets = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpEstabResets
};

const RTCSMIB_VALUE MIBVALUE_tcpCurrEstab = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpCurrEstab
};

const RTCSMIB_VALUE MIBVALUE_tcpInSegs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpInSegs
};

const RTCSMIB_VALUE MIBVALUE_tcpOutSegs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpOutSegs
};

const RTCSMIB_VALUE MIBVALUE_tcpRetransSegs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpRetransSegs
};

const RTCSMIB_VALUE MIBVALUE_tcpConnState = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpConnState
};

const RTCSMIB_VALUE MIBVALUE_tcpConnLocalAddress = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_tcpConnLocalAddress
};

const RTCSMIB_VALUE MIBVALUE_tcpConnLocalPort = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpConnLocalPort
};

const RTCSMIB_VALUE MIBVALUE_tcpConnRemAddress = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_tcpConnRemAddress
};

const RTCSMIB_VALUE MIBVALUE_tcpConnRemPort = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpConnRemPort
};

const RTCSMIB_VALUE MIBVALUE_tcpConnTable = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_tcpConnEntry = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_tcpInErrs = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_tcpOutRsts = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_udp = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_udpInDatagrams = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpInDatagrams
};

const RTCSMIB_VALUE MIBVALUE_udpNoPorts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpNoPorts
};

const RTCSMIB_VALUE MIBVALUE_udpInErrors = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpInErrors
};

const RTCSMIB_VALUE MIBVALUE_udpOutDatagrams = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpOutDatagrams
};

const RTCSMIB_VALUE MIBVALUE_udpLocalAddress = {
    RTCSMIB_NODETYPE_OCTSTR_FN,
    (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_udpLocalAddress
};

const RTCSMIB_VALUE MIBVALUE_udpLocalPort = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpLocalPort
};

const RTCSMIB_VALUE MIBVALUE_udpTable = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_udpEntry = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_transmission = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_snmp = {
    RTCSMIB_NODETYPE_INT_CONST,
    NULL
};

const RTCSMIB_VALUE MIBVALUE_snmpInPkts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInPkts
};

const RTCSMIB_VALUE MIBVALUE_snmpOutPkts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutPkts
};

const RTCSMIB_VALUE MIBVALUE_snmpInBadVersions = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInBadVersions
};

const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityNames = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInBadCommunityNames
};

const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityUses = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL  
};

const RTCSMIB_VALUE MIBVALUE_snmpInASNParseErrs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInASNParseErrs
};

const RTCSMIB_VALUE MIBVALUE_snmpInTooBigs = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL  
};

const RTCSMIB_VALUE MIBVALUE_snmpInNoSuchNames = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL  
};

const RTCSMIB_VALUE MIBVALUE_snmpInBadValues = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL  
};

const RTCSMIB_VALUE MIBVALUE_snmpInReadOnlys = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL  
};

const RTCSMIB_VALUE MIBVALUE_snmpInGenErrs = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL  
};

const RTCSMIB_VALUE MIBVALUE_snmpInTotalReqVars = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInTotalReqVars
};

const RTCSMIB_VALUE MIBVALUE_snmpInTotalSetVars = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInTotalSetVars
};

const RTCSMIB_VALUE MIBVALUE_snmpInGetRequests = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInGetRequests
};

const RTCSMIB_VALUE MIBVALUE_snmpInGetNexts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInGetNexts
};

const RTCSMIB_VALUE MIBVALUE_snmpInSetRequests = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInSetRequests
};

const RTCSMIB_VALUE MIBVALUE_snmpInGetResponses = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInGetResponses
};

const RTCSMIB_VALUE MIBVALUE_snmpInTraps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInTraps
};

const RTCSMIB_VALUE MIBVALUE_snmpOutTooBigs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutTooBigs
};

const RTCSMIB_VALUE MIBVALUE_snmpOutNoSuchNames = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutNoSuchNames
};

const RTCSMIB_VALUE MIBVALUE_snmpOutBadValues = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutBadValues
};

const RTCSMIB_VALUE MIBVALUE_snmpOutGenErrs = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGenErrs
};

const RTCSMIB_VALUE MIBVALUE_snmpOutGetRequests = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGetRequests
};

const RTCSMIB_VALUE MIBVALUE_snmpOutGetNexts = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGetNexts
};

const RTCSMIB_VALUE MIBVALUE_snmpOutSetRequests = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutSetRequests
};

const RTCSMIB_VALUE MIBVALUE_snmpOutGetResponses = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGetResponses
};

const RTCSMIB_VALUE MIBVALUE_snmpOutTraps = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutTraps
};

const RTCSMIB_VALUE MIBVALUE_snmpEnableAuthenTraps = {
    RTCSMIB_NODETYPE_UINT_CONST,
    NULL  
};

const RTCSMIB_VALUE MIBVALUE_ipInDiscards = {
    RTCSMIB_NODETYPE_UINT_FN,
    (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInDiscards
};

#endif /* RTCSCFG_ENABLE_SNMP */

/****************************************************************************/
 
void MIB1213_init(void)
{
#if RTCSCFG_ENABLE_SNMP
   RTCSMIB_mib_add(&MIBNODE_mib2);
#endif
}

/* EOF */
